vnet/vnet/lisp-gpe/ip_forward.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-gpe/lisp_gpe.h>
  17
  18 /* avoids calling route callbacks for src fib */
  19 static void
  20 ip4_sd_fib_set_adj_index (lisp_gpe_main_t * lgm, ip4_fib_t * fib, u32 flags,
  21                            u32 dst_address_u32, u32 dst_address_length,
  22                            u32 adj_index)
  23 {
  24   ip_lookup_main_t * lm = lgm->lm4;
  25   uword * hash;
  26
  27   if (vec_bytes(fib->old_hash_values))
  28     memset (fib->old_hash_values, ~0, vec_bytes (fib->old_hash_values));
  29   if (vec_bytes(fib->new_hash_values))
  30     memset (fib->new_hash_values, ~0, vec_bytes (fib->new_hash_values));
  31   fib->new_hash_values[0] = adj_index;
  32
  33   /* Make sure adj index is valid. */
  34   if (CLIB_DEBUG > 0)
  35     (void) ip_get_adjacency (lm, adj_index);
  36
  37   hash = fib->adj_index_by_dst_address[dst_address_length];
  38
  39   hash = _hash_set3 (hash, dst_address_u32,
  40                      fib->new_hash_values,
  41                      fib->old_hash_values);
  42
  43   fib->adj_index_by_dst_address[dst_address_length] = hash;
  44 }
  45
  46 /* copied from ip4_forward since it's static */
  47 static void
  48 ip4_fib_init_adj_index_by_dst_address (ip_lookup_main_t * lm,
  49                                        ip4_fib_t * fib,
  50                                        u32 address_length)
  51 {
  52   hash_t * h;
  53   uword max_index;
  54
  55   ASSERT (lm->fib_result_n_bytes >= sizeof (uword));
  56   lm->fib_result_n_words = round_pow2 (lm->fib_result_n_bytes, sizeof(uword))
  57       / sizeof(uword);
  58
  59   fib->adj_index_by_dst_address[address_length] =
  60     hash_create (32 /* elts */, lm->fib_result_n_words * sizeof (uword));
  61
  62   hash_set_flags (fib->adj_index_by_dst_address[address_length],
  63                   HASH_FLAG_NO_AUTO_SHRINK);
  64
  65   h = hash_header (fib->adj_index_by_dst_address[address_length]);
  66   max_index = (hash_value_bytes (h) / sizeof (fib->new_hash_values[0])) - 1;
  67
  68   /* Initialize new/old hash value vectors. */
  69   vec_validate_init_empty (fib->new_hash_values, max_index, ~0);
  70   vec_validate_init_empty (fib->old_hash_values, max_index, ~0);
  71 }
  72
  73 static void
  74 ip4_sd_fib_add_del_src_route (lisp_gpe_main_t * lgm,
  75                               ip4_add_del_route_args_t * a)
  76 {
  77   ip_lookup_main_t * lm = lgm->lm4;
  78   ip4_fib_t * fib;
  79   u32 dst_address, dst_address_length, adj_index, old_adj_index;
  80   uword * hash, is_del;
  81
  82   /* Either create new adjacency or use given one depending on arguments. */
  83   if (a->n_add_adj > 0)
  84       ip_add_adjacency (lm, a->add_adj, a->n_add_adj, &adj_index);
  85   else
  86     adj_index = a->adj_index;
  87
  88   dst_address = a->dst_address.data_u32;
  89   dst_address_length = a->dst_address_length;
  90
  91   fib = pool_elt_at_index(lgm->ip4_src_fibs, a->table_index_or_table_id);
  92
  93   if (! fib->adj_index_by_dst_address[dst_address_length])
  94     ip4_fib_init_adj_index_by_dst_address (lm, fib, dst_address_length);
  95
  96   hash = fib->adj_index_by_dst_address[dst_address_length];
  97
  98   is_del = (a->flags & IP4_ROUTE_FLAG_DEL) != 0;
  99
 100   if (is_del)
 101     {
 102       fib->old_hash_values[0] = ~0;
 103       hash = _hash_unset (hash, dst_address, fib->old_hash_values);
 104       fib->adj_index_by_dst_address[dst_address_length] = hash;
 105     }
 106   else
 107     ip4_sd_fib_set_adj_index (lgm, fib, a->flags, dst_address,
 108                               dst_address_length, adj_index);
 109
 110   old_adj_index = fib->old_hash_values[0];
 111
 112   /* Avoid spurious reference count increments */
 113   if (old_adj_index == adj_index
 114       && adj_index != ~0
 115       && !(a->flags & IP4_ROUTE_FLAG_KEEP_OLD_ADJACENCY))
 116     {
 117       ip_adjacency_t * adj = ip_get_adjacency (lm, adj_index);
 118       if (adj->share_count > 0)
 119         adj->share_count --;
 120     }
 121
 122   ip4_fib_mtrie_add_del_route (fib, a->dst_address, dst_address_length,
 123                                is_del ? old_adj_index : adj_index,
 124                                is_del);
 125
 126   /* Delete old adjacency index if present and changed. */
 127   if (! (a->flags & IP4_ROUTE_FLAG_KEEP_OLD_ADJACENCY)
 128       && old_adj_index != ~0
 129       && old_adj_index != adj_index)
 130     ip_del_adjacency (lm, old_adj_index);
 131 }
 132
 133 static void *
 134 ip4_sd_get_src_route (lisp_gpe_main_t * lgm, u32 src_fib_index,
 135                       ip4_address_t * src, u32 address_length)
 136 {
 137   ip4_fib_t * fib = pool_elt_at_index (lgm->ip4_src_fibs, src_fib_index);
 138   uword * hash, * p;
 139
 140   hash = fib->adj_index_by_dst_address[address_length];
 141   p = hash_get (hash, src->as_u32);
 142   return (void *) p;
 143 }
 144
 145 typedef CLIB_PACKED (struct ip4_route {
 146   ip4_address_t address;
 147   u32 address_length : 6;
 148   u32 index : 26;
 149 }) ip4_route_t;
 150
 151 void
 152 ip4_sd_fib_clear_src_fib (lisp_gpe_main_t * lgm, ip4_fib_t * fib)
 153 {
 154   ip4_route_t * routes = 0, * r;
 155   u32 i;
 156
 157   vec_reset_length (routes);
 158
 159   for (i = 0; i < ARRAY_LEN (fib->adj_index_by_dst_address); i++) {
 160       uword * hash = fib->adj_index_by_dst_address[i];
 161       hash_pair_t * p;
 162       ip4_route_t x;
 163
 164       x.address_length = i;
 165
 166       hash_foreach_pair (p, hash,
 167       ({
 168           x.address.data_u32 = p->key;
 169           vec_add1 (routes, x);
 170       }));
 171   }
 172
 173   vec_foreach (r, routes) {
 174       ip4_add_del_route_args_t a;
 175
 176       memset (&a, 0, sizeof (a));
 177       a.flags = IP4_ROUTE_FLAG_FIB_INDEX | IP4_ROUTE_FLAG_DEL;
 178       a.table_index_or_table_id = fib - lgm->ip4_src_fibs;
 179       a.dst_address = r->address;
 180       a.dst_address_length = r->address_length;
 181       a.adj_index = ~0;
 182
 183       ip4_sd_fib_add_del_src_route (lgm, &a);
 184   }
 185 }
 186
 187 static u8
 188 ip4_fib_is_empty (ip4_fib_t * fib)
 189 {
 190   u8 fib_is_empty;
 191   int i;
 192
 193   fib_is_empty = 1;
 194   for (i = ARRAY_LEN (fib->adj_index_by_dst_address) - 1; i >= 0; i--)
 195     {
 196       uword * hash = fib->adj_index_by_dst_address[i];
 197       uword n_elts = hash_elts (hash);
 198       if (n_elts)
 199         {
 200           fib_is_empty = 0;
 201           break;
 202         }
 203     }
 204   return fib_is_empty;
 205 }
 206
 207 static int
 208 ip4_sd_fib_add_del_route (lisp_gpe_main_t * lgm, ip_prefix_t * dst_prefix,
 209                           ip_prefix_t * src_prefix, u32 table_id,
 210                           ip_adjacency_t * add_adj, u8 is_add)
 211 {
 212   uword * p;
 213   ip4_add_del_route_args_t a;
 214   ip_adjacency_t * dst_adjp, dst_adj;
 215   ip4_address_t dst = ip_prefix_v4(dst_prefix), src;
 216   u32 dst_address_length = ip_prefix_len(dst_prefix), src_address_length = 0;
 217   ip4_fib_t * src_fib;
 218
 219   if (src_prefix)
 220     {
 221       src = ip_prefix_v4(src_prefix);
 222       src_address_length = ip_prefix_len(src_prefix);
 223     }
 224   else
 225     memset(&src, 0, sizeof(src));
 226
 227   /* lookup dst adj */
 228   p = ip4_get_route (lgm->im4, table_id, 0, dst.as_u8, dst_address_length);
 229
 230   if (is_add)
 231     {
 232       /* insert dst prefix to ip4 fib, if it's not in yet */
 233       if (p == 0)
 234         {
 235           /* allocate and init src ip4 fib */
 236           pool_get(lgm->ip4_src_fibs, src_fib);
 237           ip4_mtrie_init (&src_fib->mtrie);
 238
 239           /* configure adjacency */
 240           memset(&dst_adj, 0, sizeof(dst_adj));
 241
 242           /* reuse rewrite header to store pointer to src fib */
 243           dst_adj.rewrite_header.sw_if_index = src_fib - lgm->ip4_src_fibs;
 244
 245           /* dst adj should point to lisp gpe lookup */
 246           dst_adj.lookup_next_index = lgm->ip4_lookup_next_lgpe_ip4_lookup;
 247
 248           /* explicit_fib_index is used in IP6 FIB lookup, don't reuse it */
 249           dst_adj.explicit_fib_index = ~0;
 250           dst_adj.n_adj = 1;
 251
 252           /* make sure we have different signatures for adj in different tables
 253            * but with the same lookup_next_index and for adj in the same table
 254            * but associated to different destinations */
 255           dst_adj.if_address_index = table_id;
 256           dst_adj.indirect.next_hop.ip4 = dst;
 257
 258           memset(&a, 0, sizeof(a));
 259           a.flags = IP4_ROUTE_FLAG_TABLE_ID;
 260           a.table_index_or_table_id = table_id; /* vrf */
 261           a.adj_index = ~0;
 262           a.dst_address_length = dst_address_length;
 263           a.dst_address = dst;
 264           a.flags |= IP4_ROUTE_FLAG_ADD;
 265           a.add_adj = &dst_adj;
 266           a.n_add_adj = 1;
 267
 268           ip4_add_del_route (lgm->im4, &a);
 269
 270           /* lookup dst adj to obtain the adj index */
 271           p = ip4_get_route (lgm->im4, table_id, 0, dst.as_u8,
 272                              dst_address_length);
 273
 274           /* make sure insertion succeeded */
 275           if (CLIB_DEBUG)
 276             {
 277               ASSERT(p != 0);
 278               dst_adjp = ip_get_adjacency (lgm->lm4, p[0]);
 279               ASSERT(dst_adjp->rewrite_header.sw_if_index
 280                       == dst_adj.rewrite_header.sw_if_index);
 281             }
 282         }
 283     }
 284   else
 285     {
 286       if (p == 0)
 287         {
 288           clib_warning("Trying to delete inexistent dst route for %U. Aborting",
 289                        format_ip4_address_and_length, dst.as_u8,
 290                        dst_address_length);
 291           return -1;
 292         }
 293     }
 294
 295   dst_adjp = ip_get_adjacency (lgm->lm4, p[0]);
 296
 297   /* add/del src prefix to src fib */
 298   memset(&a, 0, sizeof(a));
 299   a.flags = IP4_ROUTE_FLAG_TABLE_ID;
 300   a.table_index_or_table_id = dst_adjp->rewrite_header.sw_if_index;
 301   a.adj_index = ~0;
 302   a.flags |= is_add ? IP4_ROUTE_FLAG_ADD : IP4_ROUTE_FLAG_DEL;
 303   a.add_adj = add_adj;
 304   a.n_add_adj = is_add ? 1 : 0;
 305   /* if src prefix is null, add 0/0 */
 306   a.dst_address_length = src_address_length;
 307   a.dst_address = src;
 308   ip4_sd_fib_add_del_src_route (lgm, &a);
 309
 310   /* make sure insertion succeeded */
 311   if (CLIB_DEBUG && is_add)
 312     {
 313       uword * sai;
 314       ip_adjacency_t * src_adjp;
 315       sai = ip4_sd_get_src_route (lgm, dst_adjp->rewrite_header.sw_if_index,
 316                                   &src, src_address_length);
 317       ASSERT(sai != 0);
 318       src_adjp = ip_get_adjacency(lgm->lm4, sai[0]);
 319       ASSERT(src_adjp->if_address_index == add_adj->if_address_index);
 320     }
 321
 322   /* if a delete, check if there are elements left in the src fib */
 323   if (!is_add)
 324     {
 325       src_fib = pool_elt_at_index(lgm->ip4_src_fibs,
 326                                   dst_adjp->rewrite_header.sw_if_index);
 327       if (!src_fib)
 328         return 0;
 329
 330       /* if there's nothing left */
 331       if (ip4_fib_is_empty(src_fib))
 332         {
 333           /* remove the src fib ..  */
 334           pool_put(lgm->ip4_src_fibs, src_fib);
 335
 336           /* .. and remove dst route */
 337           memset(&a, 0, sizeof(a));
 338           a.flags = IP4_ROUTE_FLAG_TABLE_ID;
 339           a.table_index_or_table_id = table_id; /* vrf */
 340           a.adj_index = ~0;
 341           a.dst_address_length = dst_address_length;
 342           a.dst_address = dst;
 343           a.flags |= IP4_ROUTE_FLAG_DEL;
 344
 345           ip4_add_del_route (lgm->im4, &a);
 346         }
 347     }
 348
 349   return 0;
 350 }
 351
 352 static void *
 353 ip4_sd_fib_get_route (lisp_gpe_main_t * lgm, ip_prefix_t * dst_prefix,
 354                       ip_prefix_t * src_prefix, u32 table_id)
 355 {
 356   uword * p;
 357   ip4_address_t dst = ip_prefix_v4(dst_prefix), src;
 358   u32 dst_address_length = ip_prefix_len(dst_prefix), src_address_length = 0;
 359   ip_adjacency_t * dst_adj;
 360
 361   if (src_prefix)
 362     {
 363       src = ip_prefix_v4(src_prefix);
 364       src_address_length = ip_prefix_len(src_prefix);
 365     }
 366   else
 367     memset(&src, 0, sizeof(src));
 368
 369   /* lookup dst adj */
 370   p = ip4_get_route (lgm->im4, table_id, 0, dst.as_u8, dst_address_length);
 371   if (p == 0)
 372       return p;
 373
 374   dst_adj = ip_get_adjacency (lgm->lm4, p[0]);
 375   return ip4_sd_get_src_route (lgm, dst_adj->rewrite_header.sw_if_index, &src,
 376                                src_address_length);
 377 }
 378
 379 static u32
 380 ip6_sd_get_src_route (lisp_gpe_main_t * lgm, u32 src_fib_index,
 381                       ip6_address_t * src, u32 address_length)
 382 {
 383   int rv;
 384   BVT(clib_bihash_kv) kv, value;
 385   ip6_src_fib_t * fib = pool_elt_at_index (lgm->ip6_src_fibs, src_fib_index);
 386
 387   ip6_address_t * mask;
 388
 389   ASSERT(address_length <= 128);
 390
 391   mask = &fib->fib_masks[address_length];
 392
 393   kv.key[0] = src->as_u64[0] & mask->as_u64[0];
 394   kv.key[1] = src->as_u64[1] & mask->as_u64[1];
 395   kv.key[2] = address_length;
 396
 397   rv = BV(clib_bihash_search_inline_2)(&fib->ip6_lookup_table, &kv, &value);
 398   if (rv == 0)
 399     return value.value;
 400
 401   return 0;
 402 }
 403
 404 static void
 405 compute_prefix_lengths_in_search_order (ip6_src_fib_t * fib)
 406 {
 407   int i;
 408   vec_reset_length(fib->prefix_lengths_in_search_order);
 409   /* Note: bitmap reversed so this is in fact a longest prefix match */
 410   clib_bitmap_foreach(i, fib->non_empty_dst_address_length_bitmap, ({
 411     int dst_address_length = 128 - i;
 412     vec_add1 (fib->prefix_lengths_in_search_order, dst_address_length);
 413   }));
 414 }
 415
 416 /* Rewrite of ip6_add_del_route() because it uses im6 to find the fib */
 417 static void
 418 ip6_sd_fib_add_del_src_route (lisp_gpe_main_t * lgm,
 419                               ip6_add_del_route_args_t * a)
 420 {
 421   ip_lookup_main_t * lm = lgm->lm6;
 422   ip6_src_fib_t * fib;
 423   ip6_address_t dst_address;
 424   u32 dst_address_length, adj_index;
 425   uword is_del;
 426   u32 old_adj_index = ~0;
 427   BVT(clib_bihash_kv) kv, value;
 428
 429   vlib_smp_unsafe_warning();
 430
 431   is_del = (a->flags & IP6_ROUTE_FLAG_DEL) != 0;
 432
 433   /* Either create new adjacency or use given one depending on arguments. */
 434   if (a->n_add_adj > 0)
 435     {
 436       ip_add_adjacency (lm, a->add_adj, a->n_add_adj, &adj_index);
 437     }
 438   else
 439     adj_index = a->adj_index;
 440
 441   dst_address = a->dst_address;
 442   dst_address_length = a->dst_address_length;
 443   fib = pool_elt_at_index(lgm->ip6_src_fibs, a->table_index_or_table_id);
 444
 445   ASSERT (dst_address_length < ARRAY_LEN (fib->fib_masks));
 446   ip6_address_mask (&dst_address, &fib->fib_masks[dst_address_length]);
 447
 448   /* refcount accounting */
 449   if (is_del)
 450     {
 451       ASSERT(fib->dst_address_length_refcounts[dst_address_length] > 0);
 452       if (--fib->dst_address_length_refcounts[dst_address_length] == 0)
 453         {
 454           fib->non_empty_dst_address_length_bitmap = clib_bitmap_set (
 455               fib->non_empty_dst_address_length_bitmap,
 456               128 - dst_address_length, 0);
 457           compute_prefix_lengths_in_search_order (fib);
 458         }
 459     }
 460   else
 461     {
 462       fib->dst_address_length_refcounts[dst_address_length]++;
 463
 464       fib->non_empty_dst_address_length_bitmap =
 465         clib_bitmap_set (fib->non_empty_dst_address_length_bitmap,
 466                              128 - dst_address_length, 1);
 467       compute_prefix_lengths_in_search_order (fib);
 468     }
 469
 470   kv.key[0] = dst_address.as_u64[0];
 471   kv.key[1] = dst_address.as_u64[1];
 472   kv.key[2] = dst_address_length;
 473
 474   if (BV(clib_bihash_search)(&fib->ip6_lookup_table, &kv, &value) == 0)
 475     old_adj_index = value.value;
 476
 477   if (is_del)
 478     BV(clib_bihash_add_del) (&fib->ip6_lookup_table, &kv, 0 /* is_add */);
 479   else
 480     {
 481       /* Make sure adj index is valid. */
 482       if (CLIB_DEBUG > 0)
 483         (void) ip_get_adjacency (lm, adj_index);
 484
 485       kv.value = adj_index;
 486
 487       BV(clib_bihash_add_del) (&fib->ip6_lookup_table, &kv, 1 /* is_add */);
 488     }
 489
 490   /* Avoid spurious reference count increments */
 491   if (old_adj_index == adj_index
 492       && !(a->flags & IP6_ROUTE_FLAG_KEEP_OLD_ADJACENCY))
 493     {
 494       ip_adjacency_t * adj = ip_get_adjacency (lm, adj_index);
 495       if (adj->share_count > 0)
 496         adj->share_count --;
 497     }
 498
 499   /* Delete old adjacency index if present and changed. */
 500   {
 501     if (! (a->flags & IP6_ROUTE_FLAG_KEEP_OLD_ADJACENCY)
 502         && old_adj_index != ~0
 503         && old_adj_index != adj_index)
 504       ip_del_adjacency (lm, old_adj_index);
 505   }
 506 }
 507
 508 static void
 509 ip6_src_fib_init (ip6_src_fib_t * fib)
 510 {
 511   uword i;
 512
 513   for (i = 0; i < ARRAY_LEN (fib->fib_masks); i++)
 514     {
 515       u32 j, i0, i1;
 516
 517       i0 = i / 32;
 518       i1 = i % 32;
 519
 520       for (j = 0; j < i0; j++)
 521         fib->fib_masks[i].as_u32[j] = ~0;
 522
 523       if (i1)
 524         fib->fib_masks[i].as_u32[i0] = clib_host_to_net_u32 (
 525             pow2_mask (i1) << (32 - i1));
 526     }
 527
 528   if (fib->lookup_table_nbuckets == 0)
 529     fib->lookup_table_nbuckets = IP6_FIB_DEFAULT_HASH_NUM_BUCKETS;
 530
 531   fib->lookup_table_nbuckets = 1 << max_log2 (fib->lookup_table_nbuckets);
 532
 533   if (fib->lookup_table_size == 0)
 534     fib->lookup_table_size = IP6_FIB_DEFAULT_HASH_MEMORY_SIZE;
 535
 536   BV(clib_bihash_init) (&fib->ip6_lookup_table, "ip6 lookup table",
 537                         fib->lookup_table_nbuckets,
 538                         fib->lookup_table_size);
 539
 540 }
 541
 542 static int
 543 ip6_sd_fib_add_del_route (lisp_gpe_main_t * lgm, ip_prefix_t * dst_prefix,
 544                           ip_prefix_t * src_prefix, u32 table_id,
 545                           ip_adjacency_t * add_adj, u8 is_add)
 546 {
 547   u32 adj_index;
 548   ip6_add_del_route_args_t a;
 549   ip_adjacency_t * dst_adjp, dst_adj;
 550   ip6_address_t dst = ip_prefix_v6(dst_prefix), src;
 551   u32 dst_address_length = ip_prefix_len(dst_prefix), src_address_length = 0;
 552   ip6_src_fib_t * src_fib;
 553
 554   if (src_prefix)
 555     {
 556       src = ip_prefix_v6(src_prefix);
 557       src_address_length = ip_prefix_len(src_prefix);
 558     }
 559   else
 560     memset(&src, 0, sizeof(src));
 561
 562   /* lookup dst adj and create it if it doesn't exist */
 563   adj_index = ip6_get_route (lgm->im6, table_id, 0, &dst, dst_address_length);
 564
 565   if (is_add)
 566     {
 567       /* insert dst prefix to ip6 fib, if it's not in yet */
 568       if (adj_index == 0)
 569         {
 570           /* allocate and init src ip6 fib */
 571           pool_get(lgm->ip6_src_fibs, src_fib);
 572           memset(src_fib, 0, sizeof(src_fib[0]));
 573           ip6_src_fib_init (src_fib);
 574
 575           memset(&dst_adj, 0, sizeof(dst_adj));
 576
 577           /* reuse rewrite header to store pointer to src fib */
 578           dst_adj.rewrite_header.sw_if_index = src_fib - lgm->ip6_src_fibs;
 579
 580           /* dst adj should point to lisp gpe ip lookup */
 581           dst_adj.lookup_next_index = lgm->ip6_lookup_next_lgpe_ip6_lookup;
 582
 583           /* explicit_fib_index is used in IP6 FIB lookup, don't reuse it */
 584           dst_adj.explicit_fib_index = ~0;
 585           dst_adj.n_adj = 1;
 586
 587           /* make sure we have different signatures for adj in different tables
 588            * but with the same lookup_next_index and for adj in the same table
 589            * but associated to different destinations */
 590           dst_adj.if_address_index = table_id;
 591           dst_adj.indirect.next_hop.ip6 = dst;
 592
 593           memset(&a, 0, sizeof(a));
 594           a.flags = IP6_ROUTE_FLAG_TABLE_ID;
 595           a.table_index_or_table_id = table_id; /* vrf */
 596           a.adj_index = ~0;
 597           a.dst_address_length = dst_address_length;
 598           a.dst_address = dst;
 599           a.flags |= IP6_ROUTE_FLAG_ADD;
 600           a.add_adj = &dst_adj;
 601           a.n_add_adj = 1;
 602
 603           ip6_add_del_route (lgm->im6, &a);
 604
 605           /* lookup dst adj to obtain the adj index */
 606           adj_index = ip6_get_route (lgm->im6, table_id, 0, &dst,
 607                                      dst_address_length);
 608
 609           /* make sure insertion succeeded */
 610           if (CLIB_DEBUG)
 611             {
 612               ASSERT(adj_index != 0);
 613               dst_adjp = ip_get_adjacency (lgm->lm6, adj_index);
 614               ASSERT(dst_adjp->rewrite_header.sw_if_index
 615                       == dst_adj.rewrite_header.sw_if_index);
 616             }
 617         }
 618     }
 619   else
 620     {
 621       if (adj_index == 0)
 622         {
 623           clib_warning("Trying to delete inexistent dst route for %U. Aborting",
 624                        format_ip_prefix, dst_prefix);
 625           return -1;
 626         }
 627     }
 628
 629   dst_adjp = ip_get_adjacency (lgm->lm6, adj_index);
 630
 631   /* add/del src prefix to src fib */
 632   memset(&a, 0, sizeof(a));
 633   a.flags = IP6_ROUTE_FLAG_TABLE_ID;
 634   a.table_index_or_table_id = dst_adjp->rewrite_header.sw_if_index;
 635   a.adj_index = ~0;
 636   a.flags |= is_add ? IP6_ROUTE_FLAG_ADD : IP6_ROUTE_FLAG_DEL;
 637   a.add_adj = add_adj;
 638   a.n_add_adj = is_add ? 1 : 0;
 639   /* if src prefix is null, add ::0 */
 640   a.dst_address_length = src_address_length;
 641   a.dst_address = src;
 642   ip6_sd_fib_add_del_src_route (lgm, &a);
 643
 644   /* make sure insertion succeeded */
 645   if (CLIB_DEBUG && is_add)
 646     {
 647       u32 sai;
 648       ip_adjacency_t * src_adjp;
 649       sai = ip6_sd_get_src_route (lgm, dst_adjp->rewrite_header.sw_if_index,
 650                                   &src, src_address_length);
 651       ASSERT(sai != 0);
 652       src_adjp = ip_get_adjacency(lgm->lm6, sai);
 653       ASSERT(src_adjp->if_address_index == add_adj->if_address_index);
 654     }
 655
 656   /* if a delete, check if there are elements left in the src fib */
 657   if (!is_add)
 658     {
 659       src_fib = pool_elt_at_index(lgm->ip6_src_fibs,
 660                                   dst_adjp->rewrite_header.sw_if_index);
 661       if (!src_fib)
 662         return 0;
 663
 664       /* if there's nothing left */
 665       if (clib_bitmap_count_set_bits (
 666           src_fib->non_empty_dst_address_length_bitmap) == 0)
 667         {
 668           /* remove src fib .. */
 669           pool_put(lgm->ip6_src_fibs, src_fib);
 670
 671           /* .. and remove dst route */
 672           memset(&a, 0, sizeof(a));
 673           a.flags = IP6_ROUTE_FLAG_TABLE_ID;
 674           a.table_index_or_table_id = table_id; /* vrf */
 675           a.adj_index = ~0;
 676           a.dst_address_length = dst_address_length;
 677           a.dst_address = dst;
 678           a.flags |= IP6_ROUTE_FLAG_DEL;
 679
 680           ip6_add_del_route (lgm->im6, &a);
 681         }
 682     }
 683
 684   return 0;
 685 }
 686
 687 static u32
 688 ip6_sd_fib_get_route (lisp_gpe_main_t * lgm, ip_prefix_t * dst_prefix,
 689                       ip_prefix_t * src_prefix, u32 table_id)
 690 {
 691   u32 adj_index;
 692   ip6_address_t dst = ip_prefix_v6(dst_prefix), src;
 693   u32 dst_address_length = ip_prefix_len(dst_prefix), src_address_length = 0;
 694   ip_adjacency_t * dst_adj;
 695
 696   if (src_prefix)
 697     {
 698       src = ip_prefix_v6(src_prefix);
 699       src_address_length = ip_prefix_len(src_prefix);
 700     }
 701   else
 702     memset(&src, 0, sizeof(src));
 703
 704   /* lookup dst adj */
 705   adj_index = ip6_get_route (lgm->im6, table_id, 0, &dst, dst_address_length);
 706   if (adj_index == 0)
 707       return adj_index;
 708
 709   dst_adj = ip_get_adjacency (lgm->lm6, adj_index);
 710   return ip6_sd_get_src_route (lgm, dst_adj->rewrite_header.sw_if_index, &src,
 711                                src_address_length);
 712 }
 713
 714 int
 715 ip_sd_fib_add_del_route (lisp_gpe_main_t * lgm, ip_prefix_t * dst_prefix,
 716                          ip_prefix_t * src_prefix, u32 table_id,
 717                          ip_adjacency_t * add_adj, u8 is_add)
 718 {
 719   return (
 720   ip_prefix_version(dst_prefix) == IP4 ?
 721       ip4_sd_fib_add_del_route : ip6_sd_fib_add_del_route) (lgm, dst_prefix,
 722                                                             src_prefix,
 723                                                             table_id, add_adj,
 724                                                             is_add);
 725 }
 726
 727 u32
 728 ip_sd_fib_get_route (lisp_gpe_main_t * lgm, ip_prefix_t * dst_prefix,
 729                      ip_prefix_t * src_prefix, u32 table_id)
 730 {
 731   if (ip_prefix_version(dst_prefix) == IP4)
 732     {
 733       u32 * adj_index = ip4_sd_fib_get_route (lgm, dst_prefix, src_prefix,
 734                                               table_id);
 735       return (adj_index == 0) ? 0 : adj_index[0];
 736     }
 737   else
 738     return ip6_sd_fib_get_route (lgm, dst_prefix, src_prefix, table_id);
 739 }
 740
 741 always_inline void
 742 ip4_src_fib_lookup_one (lisp_gpe_main_t * lgm, u32 src_fib_index0,
 743                         ip4_address_t * addr0, u32 * src_adj_index0)
 744 {
 745   ip4_fib_mtrie_leaf_t leaf0, leaf1;
 746   ip4_fib_mtrie_t * mtrie0;
 747
 748   mtrie0 = &vec_elt_at_index(lgm->ip4_src_fibs, src_fib_index0)->mtrie;
 749
 750   leaf0 = leaf1 = IP4_FIB_MTRIE_LEAF_ROOT;
 751   leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, addr0, 0);
 752   leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, addr0, 1);
 753   leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, addr0, 2);
 754   leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, addr0, 3);
 755
 756   /* Handle default route. */
 757   leaf0 = (leaf0 == IP4_FIB_MTRIE_LEAF_EMPTY ? mtrie0->default_leaf : leaf0);
 758   src_adj_index0[0] = ip4_fib_mtrie_leaf_get_adj_index (leaf0);
 759 }
 760
 761 always_inline void
 762 ip4_src_fib_lookup_two (lisp_gpe_main_t * lgm, u32 src_fib_index0,
 763                         u32 src_fib_index1, ip4_address_t * addr0,
 764                         ip4_address_t * addr1, u32 * src_adj_index0,
 765                         u32 * src_adj_index1)
 766 {
 767   ip4_fib_mtrie_leaf_t leaf0, leaf1;
 768   ip4_fib_mtrie_t * mtrie0, * mtrie1;
 769
 770   mtrie0 = &vec_elt_at_index(lgm->ip4_src_fibs, src_fib_index0)->mtrie;
 771   mtrie1 = &vec_elt_at_index(lgm->ip4_src_fibs, src_fib_index1)->mtrie;
 772
 773   leaf0 = leaf1 = IP4_FIB_MTRIE_LEAF_ROOT;
 774
 775   leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, addr0, 0);
 776   leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, addr1, 0);
 777
 778   leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, addr0, 1);
 779   leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, addr1, 1);
 780
 781   leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, addr0, 2);
 782   leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, addr1, 2);
 783
 784   leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, addr0, 3);
 785   leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, addr1, 3);
 786
 787   /* Handle default route. */
 788   leaf0 = (leaf0 == IP4_FIB_MTRIE_LEAF_EMPTY ? mtrie0->default_leaf : leaf0);
 789   leaf1 = (leaf1 == IP4_FIB_MTRIE_LEAF_EMPTY ? mtrie1->default_leaf : leaf1);
 790   src_adj_index0[0] = ip4_fib_mtrie_leaf_get_adj_index (leaf0);
 791   src_adj_index1[0] = ip4_fib_mtrie_leaf_get_adj_index (leaf1);
 792 }
 793
 794 always_inline uword
 795 lgpe_ip4_lookup (vlib_main_t * vm, vlib_node_runtime_t * node,
 796                  vlib_frame_t * from_frame)
 797 {
 798   u32 n_left_from, next_index, * from, * to_next;
 799   lisp_gpe_main_t * lgm = &lisp_gpe_main;
 800
 801   from = vlib_frame_vector_args (from_frame);
 802   n_left_from = from_frame->n_vectors;
 803
 804   next_index = node->cached_next_index;
 805
 806   while (n_left_from > 0)
 807     {
 808       u32 n_left_to_next;
 809
 810       vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next);
 811
 812       while (n_left_from >= 4 && n_left_to_next >= 2)
 813         {
 814           u32 bi0, bi1;
 815           vlib_buffer_t * b0, * b1;
 816           ip4_header_t * ip0, * ip1;
 817           u32 dst_adj_index0, src_adj_index0, src_fib_index0, dst_adj_index1,
 818               src_adj_index1, src_fib_index1;
 819           ip_adjacency_t * dst_adj0, * src_adj0, * dst_adj1, * src_adj1;
 820           u32 next0, next1;
 821
 822           next0 = next1 = LGPE_IP4_LOOKUP_NEXT_LISP_CP_LOOKUP;
 823
 824           /* Prefetch next iteration. */
 825           {
 826             vlib_buffer_t * p2, * p3;
 827
 828             p2 = vlib_get_buffer (vm, from[2]);
 829             p3 = vlib_get_buffer (vm, from[3]);
 830
 831             vlib_prefetch_buffer_header (p2, LOAD);
 832             vlib_prefetch_buffer_header (p3, LOAD);
 833
 834             CLIB_PREFETCH (p2->data, 2*CLIB_CACHE_LINE_BYTES, LOAD);
 835             CLIB_PREFETCH (p3->data, 2*CLIB_CACHE_LINE_BYTES, LOAD);
 836           }
 837
 838           bi0 = from[0];
 839           bi1 = from[1];
 840           to_next[0] = bi0;
 841           to_next[1] = bi1;
 842           from += 2;
 843           to_next += 2;
 844           n_left_to_next -= 2;
 845           n_left_from -= 2;
 846
 847           b0 = vlib_get_buffer (vm, bi0);
 848           b1 = vlib_get_buffer (vm, bi1);
 849
 850           ip0 = vlib_buffer_get_current (b0);
 851           ip1 = vlib_buffer_get_current (b1);
 852
 853           /* dst lookup was done by ip4 lookup */
 854           dst_adj_index0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
 855           dst_adj_index1 = vnet_buffer(b1)->ip.adj_index[VLIB_TX];
 856
 857           dst_adj0 = ip_get_adjacency (lgm->lm4, dst_adj_index0);
 858           dst_adj1 = ip_get_adjacency (lgm->lm4, dst_adj_index1);
 859
 860           src_fib_index0 = dst_adj0->rewrite_header.sw_if_index;
 861           src_fib_index1 = dst_adj1->rewrite_header.sw_if_index;
 862
 863           /* if default route not hit in ip4 lookup */
 864           if (PREDICT_TRUE(src_fib_index0 != (u32) ~0
 865                            && src_fib_index1 != (u32) ~0))
 866             {
 867               ip4_src_fib_lookup_two (lgm, src_fib_index0, src_fib_index1,
 868                                       &ip0->src_address, &ip1->src_address,
 869                                       &src_adj_index0, &src_adj_index1);
 870
 871               vnet_buffer(b0)->ip.adj_index[VLIB_TX] = src_adj_index0;
 872               vnet_buffer(b1)->ip.adj_index[VLIB_TX] = src_adj_index1;
 873
 874               src_adj0 = ip_get_adjacency (lgm->lm4, src_adj_index0);
 875               src_adj1 = ip_get_adjacency (lgm->lm4, src_adj_index1);
 876
 877               next0 = src_adj0->explicit_fib_index;
 878               next1 = src_adj1->explicit_fib_index;
 879
 880               /* prepare buffer for lisp-gpe output node */
 881               vnet_buffer (b0)->sw_if_index[VLIB_TX] =
 882                   src_adj0->rewrite_header.sw_if_index;
 883               vnet_buffer (b1)->sw_if_index[VLIB_TX] =
 884                   src_adj1->rewrite_header.sw_if_index;
 885             }
 886           else
 887             {
 888               if (src_fib_index0 != (u32) ~0)
 889                 {
 890                   ip4_src_fib_lookup_one (lgm, src_fib_index0,
 891                                           &ip0->src_address, &src_adj_index0);
 892                   vnet_buffer(b0)->ip.adj_index[VLIB_TX] = src_adj_index0;
 893                   src_adj0 = ip_get_adjacency (lgm->lm4, src_adj_index0);
 894                   next0 = src_adj0->explicit_fib_index;
 895                   vnet_buffer (b0)->sw_if_index[VLIB_TX] =
 896                       src_adj0->rewrite_header.sw_if_index;
 897                 }
 898               if (src_fib_index1 != (u32) ~0)
 899                 {
 900                   ip4_src_fib_lookup_one (lgm, src_fib_index1,
 901                                           &ip1->src_address, &src_adj_index1);
 902                   vnet_buffer(b1)->ip.adj_index[VLIB_TX] = src_adj_index1;
 903                   src_adj1 = ip_get_adjacency (lgm->lm4, src_adj_index1);
 904                   next1 = src_adj1->explicit_fib_index;
 905                   vnet_buffer (b1)->sw_if_index[VLIB_TX] =
 906                       src_adj1->rewrite_header.sw_if_index;
 907                 }
 908             }
 909
 910           vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next,
 911                                           n_left_to_next, bi0, bi1, next0,
 912                                           next1);
 913         }
 914
 915       while (n_left_from > 0 && n_left_to_next > 0)
 916         {
 917           vlib_buffer_t * b0;
 918           ip4_header_t * ip0;
 919           u32 bi0, dst_adj_index0, src_adj_index0, src_fib_index0;
 920           u32 next0 = LGPE_IP4_LOOKUP_NEXT_LISP_CP_LOOKUP;
 921           ip_adjacency_t * dst_adj0, * src_adj0;
 922
 923           bi0 = from[0];
 924           to_next[0] = bi0;
 925           from += 1;
 926           to_next += 1;
 927           n_left_from -= 1;
 928           n_left_to_next -= 1;
 929
 930           b0 = vlib_get_buffer (vm, bi0);
 931           ip0 = vlib_buffer_get_current (b0);
 932
 933           /* dst lookup was done by ip4 lookup */
 934           dst_adj_index0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
 935           dst_adj0 = ip_get_adjacency (lgm->lm4, dst_adj_index0);
 936           src_fib_index0 = dst_adj0->rewrite_header.sw_if_index;
 937
 938           /* if default route not hit in ip4 lookup */
 939           if (PREDICT_TRUE(src_fib_index0 != (u32 ) ~0))
 940             {
 941               /* do src lookup */
 942               ip4_src_fib_lookup_one (lgm, src_fib_index0, &ip0->src_address,
 943                                       &src_adj_index0);
 944               vnet_buffer(b0)->ip.adj_index[VLIB_TX] = src_adj_index0;
 945               src_adj0 = ip_get_adjacency (lgm->lm4, src_adj_index0);
 946               next0 = src_adj0->explicit_fib_index;
 947
 948               /* prepare packet for lisp-gpe output node */
 949               vnet_buffer (b0)->sw_if_index[VLIB_TX] =
 950                   src_adj0->rewrite_header.sw_if_index;
 951             }
 952
 953           vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next,
 954                                           n_left_to_next, bi0, next0);
 955         }
 956       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 957     }
 958   return from_frame->n_vectors;
 959 }
 960
 961 VLIB_REGISTER_NODE (lgpe_ip4_lookup_node) = {
 962   .function = lgpe_ip4_lookup,
 963   .name = "lgpe-ip4-lookup",
 964   .vector_size = sizeof (u32),
 965
 966   .type = VLIB_NODE_TYPE_INTERNAL,
 967
 968   .n_next_nodes = LGPE_IP4_LOOKUP_N_NEXT,
 969   .next_nodes = {
 970 #define _(sym,str) [LGPE_IP4_LOOKUP_NEXT_##sym] = str,
 971       foreach_lgpe_ip4_lookup_next
 972 #undef _
 973   },
 974 };
 975
 976 static u32
 977 ip6_src_fib_lookup (lisp_gpe_main_t * lgm, u32 src_fib_index,
 978                     ip6_address_t * src)
 979 {
 980   int i, len;
 981   int rv;
 982   BVT(clib_bihash_kv) kv, value;
 983   ip6_src_fib_t * fib = pool_elt_at_index (lgm->ip6_src_fibs, src_fib_index);
 984
 985   len = vec_len (fib->prefix_lengths_in_search_order);
 986
 987   for (i = 0; i < len; i++)
 988     {
 989       int dst_address_length = fib->prefix_lengths_in_search_order[i];
 990       ip6_address_t * mask;
 991
 992       ASSERT(dst_address_length >= 0 && dst_address_length <= 128);
 993
 994       mask = &fib->fib_masks[dst_address_length];
 995
 996       kv.key[0] = src->as_u64[0] & mask->as_u64[0];
 997       kv.key[1] = src->as_u64[1] & mask->as_u64[1];
 998       kv.key[2] = dst_address_length;
 999
1000       rv = BV(clib_bihash_search_inline_2)(&fib->ip6_lookup_table, &kv, &value);
1001       if (rv == 0)
1002         return value.value;
1003     }
1004
1005   return 0;
1006 }
1007
1008 always_inline uword
1009 lgpe_ip6_lookup (vlib_main_t * vm, vlib_node_runtime_t * node,
1010                  vlib_frame_t * from_frame)
1011 {
1012   u32 n_left_from, next_index, * from, * to_next;
1013   lisp_gpe_main_t * lgm = &lisp_gpe_main;
1014
1015   from = vlib_frame_vector_args (from_frame);
1016   n_left_from = from_frame->n_vectors;
1017
1018   next_index = node->cached_next_index;
1019
1020   while (n_left_from > 0)
1021     {
1022       u32 n_left_to_next;
1023
1024       vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next);
1025
1026       while (n_left_from >= 4 && n_left_to_next >= 2)
1027         {
1028           u32 bi0, bi1;
1029           vlib_buffer_t * b0, * b1;
1030           ip6_header_t * ip0, * ip1;
1031           u32 dst_adj_index0, src_adj_index0, src_fib_index0, dst_adj_index1,
1032               src_adj_index1, src_fib_index1;
1033           ip_adjacency_t * dst_adj0, * src_adj0, * dst_adj1, * src_adj1;
1034           u32 next0, next1;
1035
1036           next0 = next1 = LGPE_IP6_LOOKUP_NEXT_LISP_CP_LOOKUP;
1037
1038           /* Prefetch next iteration. */
1039           {
1040             vlib_buffer_t * p2, * p3;
1041
1042             p2 = vlib_get_buffer (vm, from[2]);
1043             p3 = vlib_get_buffer (vm, from[3]);
1044
1045             vlib_prefetch_buffer_header (p2, LOAD);
1046             vlib_prefetch_buffer_header (p3, LOAD);
1047
1048             CLIB_PREFETCH (p2->data, 2*CLIB_CACHE_LINE_BYTES, LOAD);
1049             CLIB_PREFETCH (p3->data, 2*CLIB_CACHE_LINE_BYTES, LOAD);
1050           }
1051
1052           bi0 = from[0];
1053           bi1 = from[1];
1054           to_next[0] = bi0;
1055           to_next[1] = bi1;
1056           from += 2;
1057           to_next += 2;
1058           n_left_to_next -= 2;
1059           n_left_from -= 2;
1060
1061           b0 = vlib_get_buffer (vm, bi0);
1062           b1 = vlib_get_buffer (vm, bi1);
1063
1064           ip0 = vlib_buffer_get_current (b0);
1065           ip1 = vlib_buffer_get_current (b1);
1066
1067           /* dst lookup was done by ip6 lookup */
1068           dst_adj_index0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
1069           dst_adj_index1 = vnet_buffer(b1)->ip.adj_index[VLIB_TX];
1070
1071           dst_adj0 = ip_get_adjacency (lgm->lm6, dst_adj_index0);
1072           dst_adj1 = ip_get_adjacency (lgm->lm6, dst_adj_index1);
1073
1074           src_fib_index0 = dst_adj0->rewrite_header.sw_if_index;
1075           src_fib_index1 = dst_adj1->rewrite_header.sw_if_index;
1076
1077           /* if default route not hit in ip6 lookup */
1078           if (PREDICT_TRUE(src_fib_index0 != (u32) ~0
1079                            && src_fib_index1 != (u32) ~0))
1080             {
1081               /* do src lookup */
1082               src_adj_index0 = ip6_src_fib_lookup (lgm, src_fib_index0,
1083                                                    &ip0->src_address);
1084               src_adj_index1 = ip6_src_fib_lookup (lgm, src_fib_index1,
1085                                                    &ip1->src_address);
1086
1087               vnet_buffer(b0)->ip.adj_index[VLIB_TX] = src_adj_index0;
1088               vnet_buffer(b1)->ip.adj_index[VLIB_TX] = src_adj_index1;
1089
1090               src_adj0 = ip_get_adjacency (lgm->lm6, src_adj_index0);
1091               src_adj1 = ip_get_adjacency (lgm->lm6, src_adj_index1);
1092
1093               next0 = src_adj0->explicit_fib_index;
1094               next1 = src_adj1->explicit_fib_index;
1095
1096               /* prepare buffer for lisp-gpe output node */
1097               vnet_buffer (b0)->sw_if_index[VLIB_TX] =
1098                   src_adj0->rewrite_header.sw_if_index;
1099               vnet_buffer (b1)->sw_if_index[VLIB_TX] =
1100                   src_adj1->rewrite_header.sw_if_index;
1101             }
1102           else
1103             {
1104               if (src_fib_index0 != (u32) ~0)
1105                 {
1106                   src_adj_index0 = ip6_src_fib_lookup (lgm, src_fib_index0,
1107                                                        &ip0->src_address);
1108                   vnet_buffer(b0)->ip.adj_index[VLIB_TX] = src_adj_index0;
1109                   src_adj0 = ip_get_adjacency (lgm->lm6, src_adj_index0);
1110                   next0 = src_adj0->explicit_fib_index;
1111                   vnet_buffer (b0)->sw_if_index[VLIB_TX] =
1112                       src_adj0->rewrite_header.sw_if_index;
1113                 }
1114               if (src_fib_index1 != (u32) ~0)
1115                 {
1116                   src_adj_index1 = ip6_src_fib_lookup (lgm, src_fib_index1,
1117                                                        &ip1->src_address);
1118                   vnet_buffer(b1)->ip.adj_index[VLIB_TX] = src_adj_index1;
1119                   src_adj1 = ip_get_adjacency (lgm->lm6, src_adj_index1);
1120                   next1 = src_adj1->explicit_fib_index;
1121                   vnet_buffer (b1)->sw_if_index[VLIB_TX] =
1122                       src_adj1->rewrite_header.sw_if_index;
1123                 }
1124             }
1125
1126           vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next,
1127                                           n_left_to_next, bi0, bi1, next0,
1128                                           next1);
1129         }
1130
1131       while (n_left_from > 0 && n_left_to_next > 0)
1132         {
1133           vlib_buffer_t * b0;
1134           ip6_header_t * ip0;
1135           u32 bi0, dst_adj_index0, src_adj_index0, src_fib_index0;
1136           u32 next0 = LGPE_IP6_LOOKUP_NEXT_LISP_CP_LOOKUP;
1137           ip_adjacency_t * dst_adj0, * src_adj0;
1138
1139           bi0 = from[0];
1140           to_next[0] = bi0;
1141           from += 1;
1142           to_next += 1;
1143           n_left_from -= 1;
1144           n_left_to_next -= 1;
1145
1146           b0 = vlib_get_buffer (vm, bi0);
1147           ip0 = vlib_buffer_get_current (b0);
1148
1149           /* dst lookup was done by ip6 lookup */
1150           dst_adj_index0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
1151           dst_adj0 = ip_get_adjacency (lgm->lm6, dst_adj_index0);
1152           src_fib_index0 = dst_adj0->rewrite_header.sw_if_index;
1153
1154           /* if default route not hit in ip6 lookup */
1155           if (PREDICT_TRUE(src_fib_index0 != (u32 ) ~0))
1156             {
1157               /* do src lookup */
1158               src_adj_index0 = ip6_src_fib_lookup (lgm, src_fib_index0,
1159                                                    &ip0->src_address);
1160
1161               vnet_buffer(b0)->ip.adj_index[VLIB_TX] = src_adj_index0;
1162               src_adj0 = ip_get_adjacency (lgm->lm6, src_adj_index0);
1163               next0 = src_adj0->explicit_fib_index;
1164
1165               /* prepare packet for lisp-gpe output node */
1166               vnet_buffer (b0)->sw_if_index[VLIB_TX] =
1167                   src_adj0->rewrite_header.sw_if_index;
1168             }
1169
1170           vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next,
1171                                           n_left_to_next, bi0, next0);
1172         }
1173       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1174     }
1175   return from_frame->n_vectors;
1176 }
1177
1178 VLIB_REGISTER_NODE (lgpe_ip6_lookup_node) = {
1179   .function = lgpe_ip6_lookup,
1180   .name = "lgpe-ip6-lookup",
1181   .vector_size = sizeof (u32),
1182
1183   .type = VLIB_NODE_TYPE_INTERNAL,
1184
1185   .n_next_nodes = LGPE_IP6_LOOKUP_N_NEXT,
1186   .next_nodes = {
1187 #define _(sym,str) [LGPE_IP6_LOOKUP_NEXT_##sym] = str,
1188       foreach_lgpe_ip6_lookup_next
1189 #undef _
1190   },
1191 };