src/vnet/adj/adj_nbr.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/adj/adj_nbr.h>
  17 #include <vnet/adj/adj_internal.h>
  18 #include <vnet/ethernet/arp_packet.h>
  19 #include <vnet/fib/fib_walk.h>
  20
  21 /*
  22  * Vector Hash tables of neighbour (traditional) adjacencies
  23  *  Key: interface(for the vector index), address (and its proto),
  24  *       link-type/ether-type.
  25  */
  26 static BVT(clib_bihash) **adj_nbr_tables[FIB_PROTOCOL_MAX];
  27
  28 // FIXME SIZE APPROPRIATELY. ASK DAVEB.
  29 #define ADJ_NBR_DEFAULT_HASH_NUM_BUCKETS (64 * 64)
  30 #define ADJ_NBR_DEFAULT_HASH_MEMORY_SIZE (32<<20)
  31
  32
  33 #define ADJ_NBR_SET_KEY(_key, _lt, _nh)         \
  34 {                                               \
  35     _key.key[0] = (_nh)->as_u64[0];             \
  36     _key.key[1] = (_nh)->as_u64[1];             \
  37     _key.key[2] = (_lt);                        \
  38 }
  39
  40 #define ADJ_NBR_ITF_OK(_proto, _itf)                    \
  41     (((_itf) < vec_len(adj_nbr_tables[_proto])) &&      \
  42      (NULL != adj_nbr_tables[_proto][sw_if_index]))
  43
  44 static void
  45 adj_nbr_insert (fib_protocol_t nh_proto,
  46                 vnet_link_t link_type,
  47                 const ip46_address_t *nh_addr,
  48                 u32 sw_if_index,
  49                 adj_index_t adj_index)
  50 {
  51     BVT(clib_bihash_kv) kv;
  52
  53     if (sw_if_index >= vec_len(adj_nbr_tables[nh_proto]))
  54     {
  55         vec_validate(adj_nbr_tables[nh_proto], sw_if_index);
  56     }
  57     if (NULL == adj_nbr_tables[nh_proto][sw_if_index])
  58     {
  59         adj_nbr_tables[nh_proto][sw_if_index] =
  60             clib_mem_alloc_aligned(sizeof(BVT(clib_bihash)),
  61                                    CLIB_CACHE_LINE_BYTES);
  62         memset(adj_nbr_tables[nh_proto][sw_if_index],
  63                0,
  64                sizeof(BVT(clib_bihash)));
  65
  66         BV(clib_bihash_init) (adj_nbr_tables[nh_proto][sw_if_index],
  67                               "Adjacency Neighbour table",
  68                               ADJ_NBR_DEFAULT_HASH_NUM_BUCKETS,
  69                               ADJ_NBR_DEFAULT_HASH_MEMORY_SIZE);
  70     }
  71
  72     ADJ_NBR_SET_KEY(kv, link_type, nh_addr);
  73     kv.value = adj_index;
  74
  75     BV(clib_bihash_add_del) (adj_nbr_tables[nh_proto][sw_if_index], &kv, 1);
  76 }
  77
  78 void
  79 adj_nbr_remove (adj_index_t ai,
  80                 fib_protocol_t nh_proto,
  81                 vnet_link_t link_type,
  82                 const ip46_address_t *nh_addr,
  83                 u32 sw_if_index)
  84 {
  85     BVT(clib_bihash_kv) kv;
  86
  87     if (!ADJ_NBR_ITF_OK(nh_proto, sw_if_index))
  88         return;
  89
  90     ADJ_NBR_SET_KEY(kv, link_type, nh_addr);
  91     kv.value = ai;
  92
  93     BV(clib_bihash_add_del) (adj_nbr_tables[nh_proto][sw_if_index], &kv, 0);
  94 }
  95
  96 static adj_index_t
  97 adj_nbr_find (fib_protocol_t nh_proto,
  98               vnet_link_t link_type,
  99               const ip46_address_t *nh_addr,
 100               u32 sw_if_index)
 101 {
 102     BVT(clib_bihash_kv) kv;
 103
 104     ADJ_NBR_SET_KEY(kv, link_type, nh_addr);
 105
 106     if (!ADJ_NBR_ITF_OK(nh_proto, sw_if_index))
 107         return (ADJ_INDEX_INVALID);
 108
 109     if (BV(clib_bihash_search)(adj_nbr_tables[nh_proto][sw_if_index],
 110                                &kv, &kv) < 0)
 111     {
 112         return (ADJ_INDEX_INVALID);
 113     }
 114     else
 115     {
 116         return (kv.value);
 117     }
 118 }
 119
 120 static inline u32
 121 adj_get_nd_node (fib_protocol_t proto)
 122 {
 123     switch (proto) {
 124     case FIB_PROTOCOL_IP4:
 125         return (ip4_arp_node.index);
 126     case FIB_PROTOCOL_IP6:
 127         return (ip6_discover_neighbor_node.index);
 128     case FIB_PROTOCOL_MPLS:
 129         break;
 130     }
 131     ASSERT(0);
 132     return (ip4_arp_node.index);
 133 }
 134
 135 /**
 136  * @brief Check and set feature flags if o/p interface has any o/p features.
 137  */
 138 static void
 139 adj_nbr_evaluate_feature (adj_index_t ai)
 140 {
 141     ip_adjacency_t *adj;
 142     vnet_feature_main_t *fm = &feature_main;
 143     i16 feature_count;
 144     u8 arc_index;
 145     u32 sw_if_index;
 146
 147     adj = adj_get(ai);
 148
 149     switch (adj->ia_link)
 150     {
 151     case VNET_LINK_IP4:
 152         arc_index = ip4_main.lookup_main.output_feature_arc_index;
 153         break;
 154     case VNET_LINK_IP6:
 155         arc_index = ip6_main.lookup_main.output_feature_arc_index;
 156         break;
 157     case VNET_LINK_MPLS:
 158         arc_index = mpls_main.output_feature_arc_index;
 159         break;
 160     default:
 161         return;
 162     }
 163
 164     sw_if_index = adj->rewrite_header.sw_if_index;
 165     vec_validate (fm->feature_count_by_sw_if_index[arc_index], sw_if_index);
 166     feature_count = fm->feature_count_by_sw_if_index[arc_index][sw_if_index];
 167
 168     if (feature_count > 0)
 169         adj->rewrite_header.flags |= VNET_REWRITE_HAS_FEATURES;
 170     else
 171         adj->rewrite_header.flags &= ~VNET_REWRITE_HAS_FEATURES;
 172
 173     return;
 174 }
 175
 176 static ip_adjacency_t*
 177 adj_nbr_alloc (fib_protocol_t nh_proto,
 178                vnet_link_t link_type,
 179                const ip46_address_t *nh_addr,
 180                u32 sw_if_index)
 181 {
 182     ip_adjacency_t *adj;
 183
 184     adj = adj_alloc(nh_proto);
 185
 186     adj_nbr_insert(nh_proto, link_type, nh_addr,
 187                    sw_if_index,
 188                    adj_get_index(adj));
 189
 190     /*
 191      * since we just added the ADJ we have no rewrite string for it,
 192      * so its for ARP
 193      */
 194     adj->lookup_next_index = IP_LOOKUP_NEXT_ARP;
 195     adj->sub_type.nbr.next_hop = *nh_addr;
 196     adj->ia_link = link_type;
 197     adj->ia_nh_proto = nh_proto;
 198     adj->rewrite_header.sw_if_index = sw_if_index;
 199     memset(&adj->sub_type.midchain.next_dpo, 0,
 200            sizeof(adj->sub_type.midchain.next_dpo));
 201
 202     adj_nbr_evaluate_feature (adj_get_index(adj));
 203     return (adj);
 204 }
 205
 206 /*
 207  * adj_nbr_add_or_lock
 208  *
 209  * Add an adjacency for the neighbour requested.
 210  *
 211  * The key for an adj is:
 212  *   - the Next-hops protocol (i.e. v4 or v6)
 213  *   - the address of the next-hop
 214  *   - the interface the next-hop is reachable through
 215  */
 216 adj_index_t
 217 adj_nbr_add_or_lock (fib_protocol_t nh_proto,
 218                      vnet_link_t link_type,
 219                      const ip46_address_t *nh_addr,
 220                      u32 sw_if_index)
 221 {
 222     adj_index_t adj_index;
 223     ip_adjacency_t *adj;
 224
 225     adj_index = adj_nbr_find(nh_proto, link_type, nh_addr, sw_if_index);
 226
 227     if (ADJ_INDEX_INVALID == adj_index)
 228     {
 229         vnet_main_t *vnm;
 230
 231         vnm = vnet_get_main();
 232         adj = adj_nbr_alloc(nh_proto, link_type, nh_addr, sw_if_index);
 233         adj_index = adj_get_index(adj);
 234         adj_lock(adj_index);
 235
 236         vnet_rewrite_init(vnm, sw_if_index,
 237                           adj_get_nd_node(nh_proto),
 238                           vnet_tx_node_index_for_sw_interface(vnm, sw_if_index),
 239                           &adj->rewrite_header);
 240
 241         /*
 242          * we need a rewrite where the destination IP address is converted
 243          * to the appropriate link-layer address. This is interface specific.
 244          * So ask the interface to do it.
 245          */
 246         vnet_update_adjacency_for_sw_interface(vnm, sw_if_index, adj_index);
 247     }
 248     else
 249     {
 250         adj_lock(adj_index);
 251     }
 252
 253     return (adj_index);
 254 }
 255
 256 adj_index_t
 257 adj_nbr_add_or_lock_w_rewrite (fib_protocol_t nh_proto,
 258                                vnet_link_t link_type,
 259                                const ip46_address_t *nh_addr,
 260                                u32 sw_if_index,
 261                                u8 *rewrite)
 262 {
 263     adj_index_t adj_index;
 264     ip_adjacency_t *adj;
 265
 266     adj_index = adj_nbr_find(nh_proto, link_type, nh_addr, sw_if_index);
 267
 268     if (ADJ_INDEX_INVALID == adj_index)
 269     {
 270         adj = adj_nbr_alloc(nh_proto, link_type, nh_addr, sw_if_index);
 271         adj->rewrite_header.sw_if_index = sw_if_index;
 272     }
 273     else
 274     {
 275         adj = adj_get(adj_index);
 276     }
 277
 278     adj_lock(adj_get_index(adj));
 279     adj_nbr_update_rewrite(adj_get_index(adj),
 280                            ADJ_NBR_REWRITE_FLAG_COMPLETE,
 281                            rewrite);
 282
 283     return (adj_get_index(adj));
 284 }
 285
 286 /**
 287  * adj_nbr_update_rewrite
 288  *
 289  * Update the adjacency's rewrite string. A NULL string implies the
 290  * rewirte is reset (i.e. when ARP/ND etnry is gone).
 291  * NB: the adj being updated may be handling traffic in the DP.
 292  */
 293 void
 294 adj_nbr_update_rewrite (adj_index_t adj_index,
 295                         adj_nbr_rewrite_flag_t flags,
 296                         u8 *rewrite)
 297 {
 298     ip_adjacency_t *adj;
 299
 300     ASSERT(ADJ_INDEX_INVALID != adj_index);
 301
 302     adj = adj_get(adj_index);
 303
 304     if (flags & ADJ_NBR_REWRITE_FLAG_COMPLETE)
 305     {
 306         /*
 307          * update the adj's rewrite string and build the arc
 308          * from the rewrite node to the interface's TX node
 309          */
 310         adj_nbr_update_rewrite_internal(adj, IP_LOOKUP_NEXT_REWRITE,
 311                                         adj_get_rewrite_node(adj->ia_link),
 312                                         vnet_tx_node_index_for_sw_interface(
 313                                             vnet_get_main(),
 314                                             adj->rewrite_header.sw_if_index),
 315                                         rewrite);
 316     }
 317     else
 318     {
 319         adj_nbr_update_rewrite_internal(adj, IP_LOOKUP_NEXT_ARP,
 320                                         adj_get_nd_node(adj->ia_nh_proto),
 321                                         vnet_tx_node_index_for_sw_interface(
 322                                             vnet_get_main(),
 323                                             adj->rewrite_header.sw_if_index),
 324                                         rewrite);
 325     }
 326 }
 327
 328 /**
 329  * adj_nbr_update_rewrite_internal
 330  *
 331  * Update the adjacency's rewrite string. A NULL string implies the
 332  * rewirte is reset (i.e. when ARP/ND etnry is gone).
 333  * NB: the adj being updated may be handling traffic in the DP.
 334  */
 335 void
 336 adj_nbr_update_rewrite_internal (ip_adjacency_t *adj,
 337                                  u32 adj_next_index,
 338                                  u32 this_node,
 339                                  u32 next_node,
 340                                  u8 *rewrite)
 341 {
 342     ip_adjacency_t *walk_adj;
 343     adj_index_t walk_ai;
 344     vlib_main_t * vm;
 345     u32 old_next;
 346     int do_walk;
 347
 348     vm = vlib_get_main();
 349     old_next = adj->lookup_next_index;
 350
 351     walk_ai = adj_get_index(adj);
 352     if (VNET_LINK_MPLS == adj->ia_link)
 353     {
 354         /*
 355          * The link type MPLS has no children in the control plane graph, it only
 356          * has children in the data-palne graph. The backwalk is up the former.
 357          * So we need to walk from its IP cousin.
 358          */
 359         walk_ai = adj_nbr_find(adj->ia_nh_proto,
 360                                fib_proto_to_link(adj->ia_nh_proto),
 361                                &adj->sub_type.nbr.next_hop,
 362                                adj->rewrite_header.sw_if_index);
 363     }
 364
 365     /*
 366      * Don't call the walk re-entrantly
 367      */
 368     if (ADJ_INDEX_INVALID != walk_ai)
 369     {
 370         walk_adj = adj_get(walk_ai);
 371         if (IP_ADJ_SYNC_WALK_ACTIVE & walk_adj->ia_flags)
 372         {
 373             do_walk = 0;
 374         }
 375         else
 376         {
 377             /*
 378              * Prevent re-entrant walk of the same adj
 379              */
 380             walk_adj->ia_flags |= IP_ADJ_SYNC_WALK_ACTIVE;
 381             do_walk = 1;
 382         }
 383     }
 384     else
 385     {
 386         do_walk = 0;
 387     }
 388
 389     /*
 390      * lock the adjacencies that are affected by updates this walk will provoke.
 391      * Since the aim of the walk is to update children to link to a different
 392      * DPO, this adj will no longer be in use and its lock count will drop to 0.
 393      * We don't want it to be deleted as part of this endevour.
 394      */
 395     adj_lock(adj_get_index(adj));
 396     adj_lock(walk_ai);
 397
 398     /*
 399      * Updating a rewrite string is not atomic;
 400      *  - the rewrite string is too long to write in one instruction
 401      *  - when swapping from incomplete to complete, we also need to update
 402      *    the VLIB graph next-index of the adj.
 403      * ideally we would only want to suspend forwarding via this adj whilst we
 404      * do this, but we do not have that level of granularity - it's suspend all
 405      * worker threads or nothing.
 406      * The other chioces are:
 407      *  - to mark the adj down and back walk so child load-balances drop this adj
 408      *    from the set.
 409      *  - update the next_node index of this adj to point to error-drop
 410      * both of which will mean for MAC change we will drop for this adj
 411      * which is not acceptable. However, when the adj changes type (from
 412      * complete to incomplete and vice-versa) the child DPOs, which have the
 413      * VLIB graph next node index, will be sending packets to the wrong graph
 414      * node. So from the options above, updating the next_node of the adj to
 415      * be drop will work, but it relies on each graph node v4/v6/mpls, rewrite/
 416      * arp/midchain always be valid w.r.t. a mis-match of adj type and node type
 417      * (i.e. a rewrite adj in the arp node). This is not enforcable. Getting it
 418      * wrong will lead to hard to find bugs since its a race condition. So we
 419      * choose the more reliable method of updating the children to use the drop,
 420      * then switching adj's type, then updating the children again. Did I mention
 421      * that this doesn't happen often...
 422      * So we need to distinguish between the two cases:
 423      *  1 - mac change
 424      *  2 - adj type change
 425      */
 426     if (do_walk &&
 427         old_next != adj_next_index &&
 428         ADJ_INDEX_INVALID != walk_ai)
 429     {
 430         /*
 431          * the adj is changing type. we need to fix all children so that they
 432          * stack momentarily on a drop, while the adj changes. If we don't do
 433          * this  the children will send packets to a VLIB graph node that does
 434          * not correspond to the adj's type - and it goes downhill from there.
 435          */
 436         fib_node_back_walk_ctx_t bw_ctx = {
 437             .fnbw_reason = FIB_NODE_BW_REASON_FLAG_ADJ_DOWN,
 438             /*
 439              * force this walk to be synchrous. if we don't and a node in the graph
 440              * (a heavily shared path-list) chooses to back-ground the walk (make it
 441              * async) then it will pause and we will do the adj update below, before
 442              * all the children are updated. not good.
 443              */
 444             .fnbw_flags = FIB_NODE_BW_FLAG_FORCE_SYNC,
 445         };
 446
 447         fib_walk_sync(FIB_NODE_TYPE_ADJ, walk_ai, &bw_ctx);
 448     }
 449
 450     /*
 451      * If we are just updating the MAC string of the adj (which we also can't
 452      * do atomically), then we need to stop packets switching through the adj.
 453      * We can't do that on a per-adj basis, so it's all the packets.
 454      * If we are updating the type, and we walked back to the children above,
 455      * then this barrier serves to flush the queues/frames.
 456      */
 457     vlib_worker_thread_barrier_sync(vm);
 458
 459     adj->lookup_next_index = adj_next_index;
 460
 461     if (NULL != rewrite)
 462     {
 463         /*
 464          * new rewrite provided.
 465          * fill in the adj's rewrite string, and build the VLIB graph arc.
 466          */
 467         vnet_rewrite_set_data_internal(&adj->rewrite_header,
 468                                        sizeof(adj->rewrite_data),
 469                                        rewrite,
 470                                        vec_len(rewrite));
 471         vec_free(rewrite);
 472     }
 473     else
 474     {
 475         vnet_rewrite_clear_data_internal(&adj->rewrite_header,
 476                                          sizeof(adj->rewrite_data));
 477     }
 478     adj->rewrite_header.next_index = vlib_node_add_next(vlib_get_main(),
 479                                                         this_node,
 480                                                         next_node);
 481
 482     /*
 483      * done with the rewirte update - let the workers loose.
 484      */
 485     vlib_worker_thread_barrier_release(vm);
 486
 487     if (do_walk &&
 488         (old_next != adj->lookup_next_index) &&
 489         (ADJ_INDEX_INVALID != walk_ai))
 490     {
 491         /*
 492          * backwalk to the children so they can stack on the now updated
 493          * adjacency
 494          */
 495         fib_node_back_walk_ctx_t bw_ctx = {
 496             .fnbw_reason = FIB_NODE_BW_REASON_FLAG_ADJ_UPDATE,
 497         };
 498
 499         fib_walk_sync(FIB_NODE_TYPE_ADJ, walk_ai, &bw_ctx);
 500     }
 501     /*
 502      * Prevent re-entrant walk of the same adj
 503      */
 504     if (do_walk)
 505     {
 506         walk_adj->ia_flags &= ~IP_ADJ_SYNC_WALK_ACTIVE;
 507     }
 508
 509     adj_unlock(adj_get_index(adj));
 510     adj_unlock(walk_ai);
 511 }
 512
 513 typedef struct adj_db_count_ctx_t_ {
 514     u64 count;
 515 } adj_db_count_ctx_t;
 516
 517 static void
 518 adj_db_count (BVT(clib_bihash_kv) * kvp,
 519               void *arg)
 520 {
 521     adj_db_count_ctx_t * ctx = arg;
 522     ctx->count++;
 523 }
 524
 525 u32
 526 adj_nbr_db_size (void)
 527 {
 528     adj_db_count_ctx_t ctx = {
 529         .count = 0,
 530     };
 531     fib_protocol_t proto;
 532     u32 sw_if_index = 0;
 533
 534     for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
 535     {
 536         vec_foreach_index(sw_if_index, adj_nbr_tables[proto])
 537         {
 538             if (NULL != adj_nbr_tables[proto][sw_if_index])
 539             {
 540                 BV(clib_bihash_foreach_key_value_pair) (
 541                     adj_nbr_tables[proto][sw_if_index],
 542                     adj_db_count,
 543                     &ctx);
 544             }
 545         }
 546     }
 547     return (ctx.count);
 548 }
 549
 550 /**
 551  * @brief Context for a walk of the adjacency neighbour DB
 552  */
 553 typedef struct adj_walk_ctx_t_
 554 {
 555     adj_walk_cb_t awc_cb;
 556     void *awc_ctx;
 557 } adj_walk_ctx_t;
 558
 559 static void
 560 adj_nbr_walk_cb (BVT(clib_bihash_kv) * kvp,
 561                  void *arg)
 562 {
 563     adj_walk_ctx_t *ctx = arg;
 564
 565     // FIXME: can't stop early...
 566     ctx->awc_cb(kvp->value, ctx->awc_ctx);
 567 }
 568
 569 void
 570 adj_nbr_walk (u32 sw_if_index,
 571               fib_protocol_t adj_nh_proto,
 572               adj_walk_cb_t cb,
 573               void *ctx)
 574 {
 575     if (!ADJ_NBR_ITF_OK(adj_nh_proto, sw_if_index))
 576         return;
 577
 578     adj_walk_ctx_t awc = {
 579         .awc_ctx = ctx,
 580         .awc_cb = cb,
 581     };
 582
 583     BV(clib_bihash_foreach_key_value_pair) (
 584         adj_nbr_tables[adj_nh_proto][sw_if_index],
 585         adj_nbr_walk_cb,
 586         &awc);
 587 }
 588
 589 /**
 590  * @brief Context for a walk of the adjacency neighbour DB
 591  */
 592 typedef struct adj_walk_nh_ctx_t_
 593 {
 594     adj_walk_cb_t awc_cb;
 595     void *awc_ctx;
 596     const ip46_address_t *awc_nh;
 597 } adj_walk_nh_ctx_t;
 598
 599 static void
 600 adj_nbr_walk_nh_cb (BVT(clib_bihash_kv) * kvp,
 601                     void *arg)
 602 {
 603     ip_adjacency_t *adj;
 604     adj_walk_nh_ctx_t *ctx = arg;
 605
 606     adj = adj_get(kvp->value);
 607
 608     if (!ip46_address_cmp(&adj->sub_type.nbr.next_hop, ctx->awc_nh))
 609         ctx->awc_cb(kvp->value, ctx->awc_ctx);
 610 }
 611
 612 /**
 613  * @brief Walk adjacencies on a link with a given v4 next-hop.
 614  * that is visit the adjacencies with different link types.
 615  */
 616 void
 617 adj_nbr_walk_nh4 (u32 sw_if_index,
 618                  const ip4_address_t *addr,
 619                  adj_walk_cb_t cb,
 620                  void *ctx)
 621 {
 622     if (!ADJ_NBR_ITF_OK(FIB_PROTOCOL_IP4, sw_if_index))
 623         return;
 624
 625     ip46_address_t nh = {
 626         .ip4 = *addr,
 627     };
 628
 629     adj_walk_nh_ctx_t awc = {
 630         .awc_ctx = ctx,
 631         .awc_cb = cb,
 632         .awc_nh = &nh,
 633     };
 634
 635     BV(clib_bihash_foreach_key_value_pair) (
 636         adj_nbr_tables[FIB_PROTOCOL_IP4][sw_if_index],
 637         adj_nbr_walk_nh_cb,
 638         &awc);
 639 }
 640
 641 /**
 642  * @brief Walk adjacencies on a link with a given v6 next-hop.
 643  * that is visit the adjacencies with different link types.
 644  */
 645 void
 646 adj_nbr_walk_nh6 (u32 sw_if_index,
 647                  const ip6_address_t *addr,
 648                  adj_walk_cb_t cb,
 649                  void *ctx)
 650 {
 651     if (!ADJ_NBR_ITF_OK(FIB_PROTOCOL_IP6, sw_if_index))
 652         return;
 653
 654     ip46_address_t nh = {
 655         .ip6 = *addr,
 656     };
 657
 658     adj_walk_nh_ctx_t awc = {
 659         .awc_ctx = ctx,
 660         .awc_cb = cb,
 661         .awc_nh = &nh,
 662     };
 663
 664     BV(clib_bihash_foreach_key_value_pair) (
 665         adj_nbr_tables[FIB_PROTOCOL_IP6][sw_if_index],
 666         adj_nbr_walk_nh_cb,
 667         &awc);
 668 }
 669
 670 /**
 671  * @brief Walk adjacencies on a link with a given next-hop.
 672  * that is visit the adjacencies with different link types.
 673  */
 674 void
 675 adj_nbr_walk_nh (u32 sw_if_index,
 676                  fib_protocol_t adj_nh_proto,
 677                  const ip46_address_t *nh,
 678                  adj_walk_cb_t cb,
 679                  void *ctx)
 680 {
 681     if (!ADJ_NBR_ITF_OK(adj_nh_proto, sw_if_index))
 682         return;
 683
 684     adj_walk_nh_ctx_t awc = {
 685         .awc_ctx = ctx,
 686         .awc_cb = cb,
 687         .awc_nh = nh,
 688     };
 689
 690     BV(clib_bihash_foreach_key_value_pair) (
 691         adj_nbr_tables[adj_nh_proto][sw_if_index],
 692         adj_nbr_walk_nh_cb,
 693         &awc);
 694 }
 695
 696 /**
 697  * Flags associated with the interface state walks
 698  */
 699 typedef enum adj_nbr_interface_flags_t_
 700 {
 701     ADJ_NBR_INTERFACE_UP = (1 << 0),
 702 } adj_nbr_interface_flags_t;
 703
 704 /**
 705  * Context for the state change walk of the DB
 706  */
 707 typedef struct adj_nbr_interface_state_change_ctx_t_
 708 {
 709     /**
 710      * Flags on the interface
 711      */
 712     adj_nbr_interface_flags_t flags;
 713 } adj_nbr_interface_state_change_ctx_t;
 714
 715 static adj_walk_rc_t
 716 adj_nbr_interface_state_change_one (adj_index_t ai,
 717                                     void *arg)
 718 {
 719     /*
 720      * Back walk the graph to inform the forwarding entries
 721      * that this interface state has changed. Do this synchronously
 722      * since this is the walk that provides convergence
 723      */
 724     adj_nbr_interface_state_change_ctx_t *ctx = arg;
 725
 726     fib_node_back_walk_ctx_t bw_ctx = {
 727         .fnbw_reason = ((ctx->flags & ADJ_NBR_INTERFACE_UP) ?
 728                         FIB_NODE_BW_REASON_FLAG_INTERFACE_UP :
 729                         FIB_NODE_BW_REASON_FLAG_INTERFACE_DOWN),
 730         /*
 731          * the force sync applies only as far as the first fib_entry.
 732          * And it's the fib_entry's we need to converge away from
 733          * the adjacencies on the now down link
 734          */
 735         .fnbw_flags = (!(ctx->flags & ADJ_NBR_INTERFACE_UP) ?
 736                        FIB_NODE_BW_FLAG_FORCE_SYNC :
 737                        0),
 738     };
 739
 740     fib_walk_sync(FIB_NODE_TYPE_ADJ, ai, &bw_ctx);
 741
 742     return (ADJ_WALK_RC_CONTINUE);
 743 }
 744
 745 /**
 746  * @brief Registered function for SW interface state changes
 747  */
 748 static clib_error_t *
 749 adj_nbr_sw_interface_state_change (vnet_main_t * vnm,
 750                                    u32 sw_if_index,
 751                                    u32 flags)
 752 {
 753     fib_protocol_t proto;
 754
 755     /*
 756      * walk each adj on the interface and trigger a walk from that adj
 757      */
 758     for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
 759     {
 760         adj_nbr_interface_state_change_ctx_t ctx = {
 761             .flags = ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ?
 762                       ADJ_NBR_INTERFACE_UP :
 763                       0),
 764         };
 765
 766         adj_nbr_walk(sw_if_index, proto,
 767                      adj_nbr_interface_state_change_one,
 768                      &ctx);
 769     }
 770
 771     return (NULL);
 772 }
 773
 774 VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION_PRIO(
 775     adj_nbr_sw_interface_state_change,
 776     VNET_ITF_FUNC_PRIORITY_HIGH);
 777
 778 /**
 779  * @brief Invoked on each SW interface of a HW interface when the
 780  * HW interface state changes
 781  */
 782 static void
 783 adj_nbr_hw_sw_interface_state_change (vnet_main_t * vnm,
 784                                       u32 sw_if_index,
 785                                       void *arg)
 786 {
 787     adj_nbr_interface_state_change_ctx_t *ctx = arg;
 788     fib_protocol_t proto;
 789
 790     /*
 791      * walk each adj on the interface and trigger a walk from that adj
 792      */
 793     for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
 794     {
 795         adj_nbr_walk(sw_if_index, proto,
 796                      adj_nbr_interface_state_change_one,
 797                      ctx);
 798     }
 799 }
 800
 801 /**
 802  * @brief Registered callback for HW interface state changes
 803  */
 804 static clib_error_t *
 805 adj_nbr_hw_interface_state_change (vnet_main_t * vnm,
 806                                    u32 hw_if_index,
 807                                    u32 flags)
 808 {
 809     /*
 810      * walk SW interface on the HW
 811      */
 812     adj_nbr_interface_state_change_ctx_t ctx = {
 813         .flags = ((flags & VNET_HW_INTERFACE_FLAG_LINK_UP) ?
 814                   ADJ_NBR_INTERFACE_UP :
 815                   0),
 816     };
 817
 818     vnet_hw_interface_walk_sw(vnm, hw_if_index,
 819                               adj_nbr_hw_sw_interface_state_change,
 820                               &ctx);
 821
 822     return (NULL);
 823 }
 824
 825 VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION_PRIO(
 826     adj_nbr_hw_interface_state_change,
 827     VNET_ITF_FUNC_PRIORITY_HIGH);
 828
 829 static adj_walk_rc_t
 830 adj_nbr_interface_delete_one (adj_index_t ai,
 831                               void *arg)
 832 {
 833     /*
 834      * Back walk the graph to inform the forwarding entries
 835      * that this interface has been deleted.
 836      */
 837     fib_node_back_walk_ctx_t bw_ctx = {
 838         .fnbw_reason = FIB_NODE_BW_REASON_FLAG_INTERFACE_DELETE,
 839     };
 840
 841     fib_walk_sync(FIB_NODE_TYPE_ADJ, ai, &bw_ctx);
 842
 843     return (ADJ_WALK_RC_CONTINUE);
 844 }
 845
 846 /**
 847  * adj_nbr_interface_add_del
 848  *
 849  * Registered to receive interface Add and delete notifications
 850  */
 851 static clib_error_t *
 852 adj_nbr_interface_add_del (vnet_main_t * vnm,
 853                            u32 sw_if_index,
 854                            u32 is_add)
 855 {
 856     fib_protocol_t proto;
 857
 858     if (is_add)
 859     {
 860         /*
 861          * not interested in interface additions. we will not back walk
 862          * to resolve paths through newly added interfaces. Why? The control
 863          * plane should have the brains to add interfaces first, then routes.
 864          * So the case where there are paths with a interface that matches
 865          * one just created is the case where the path resolved through an
 866          * interface that was deleted, and still has not been removed. The
 867          * new interface added, is NO GUARANTEE that the interface being
 868          * added now, even though it may have the same sw_if_index, is the
 869          * same interface that the path needs. So tough!
 870          * If the control plane wants these routes to resolve it needs to
 871          * remove and add them again.
 872          */
 873         return (NULL);
 874     }
 875
 876     for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
 877     {
 878         adj_nbr_walk(sw_if_index, proto,
 879                      adj_nbr_interface_delete_one,
 880                      NULL);
 881     }
 882
 883     return (NULL);
 884
 885 }
 886
 887 VNET_SW_INTERFACE_ADD_DEL_FUNCTION(adj_nbr_interface_add_del);
 888
 889
 890 static adj_walk_rc_t
 891 adj_nbr_show_one (adj_index_t ai,
 892                   void *arg)
 893 {
 894     vlib_cli_output (arg, "[@%d]  %U",
 895                      ai,
 896                      format_ip_adjacency, ai,
 897                      FORMAT_IP_ADJACENCY_NONE);
 898
 899     return (ADJ_WALK_RC_CONTINUE);
 900 }
 901
 902 static clib_error_t *
 903 adj_nbr_show (vlib_main_t * vm,
 904               unformat_input_t * input,
 905               vlib_cli_command_t * cmd)
 906 {
 907     adj_index_t ai = ADJ_INDEX_INVALID;
 908     u32 sw_if_index = ~0;
 909
 910     while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 911     {
 912         if (unformat (input, "%d", &ai))
 913             ;
 914         else if (unformat (input, "%U",
 915                            unformat_vnet_sw_interface, vnet_get_main(),
 916                            &sw_if_index))
 917             ;
 918         else
 919             break;
 920     }
 921
 922     if (ADJ_INDEX_INVALID != ai)
 923     {
 924         vlib_cli_output (vm, "[@%d] %U",
 925                          ai,
 926                          format_ip_adjacency, ai,
 927                          FORMAT_IP_ADJACENCY_DETAIL);
 928     }
 929     else if (~0 != sw_if_index)
 930     {
 931         fib_protocol_t proto;
 932
 933         for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
 934         {
 935             adj_nbr_walk(sw_if_index, proto,
 936                          adj_nbr_show_one,
 937                          vm);
 938         }
 939     }
 940     else
 941     {
 942         fib_protocol_t proto;
 943
 944         for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
 945         {
 946             vec_foreach_index(sw_if_index, adj_nbr_tables[proto])
 947             {
 948                 adj_nbr_walk(sw_if_index, proto,
 949                              adj_nbr_show_one,
 950                              vm);
 951             }
 952         }
 953     }
 954
 955     return 0;
 956 }
 957
 958 /*?
 959  * Show all neighbour adjacencies.
 960  * @cliexpar
 961  * @cliexstart{sh adj nbr}
 962  * [@2] ipv4 via 1.0.0.2 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
 963  * [@3] mpls via 1.0.0.2 loop0: MPLS_UNICAST: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
 964  * [@4] ipv4 via 1.0.0.3 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
 965  * [@5] mpls via 1.0.0.3 loop0: MPLS_UNICAST: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
 966  * @cliexend
 967  ?*/
 968 VLIB_CLI_COMMAND (ip4_show_fib_command, static) = {
 969     .path = "show adj nbr",
 970     .short_help = "show adj nbr [<adj_index>] [interface]",
 971     .function = adj_nbr_show,
 972 };
 973
 974 static ip46_type_t
 975 adj_proto_to_46 (fib_protocol_t proto)
 976 {
 977     switch (proto)
 978     {
 979     case FIB_PROTOCOL_IP4:
 980         return (IP46_TYPE_IP4);
 981     case FIB_PROTOCOL_IP6:
 982         return (IP46_TYPE_IP6);
 983     default:
 984         return (IP46_TYPE_IP4);
 985     }
 986     return (IP46_TYPE_IP4);
 987 }
 988
 989 u8*
 990 format_adj_nbr_incomplete (u8* s, va_list *ap)
 991 {
 992     index_t index = va_arg(*ap, index_t);
 993     CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
 994     vnet_main_t * vnm = vnet_get_main();
 995     ip_adjacency_t * adj = adj_get(index);
 996
 997     s = format (s, "arp-%U", format_vnet_link, adj->ia_link);
 998     s = format (s, ": via %U",
 999                 format_ip46_address, &adj->sub_type.nbr.next_hop,
1000                 adj_proto_to_46(adj->ia_nh_proto));
1001     s = format (s, " %U",
1002                 format_vnet_sw_interface_name,
1003                 vnm,
1004                 vnet_get_sw_interface(vnm,
1005                                       adj->rewrite_header.sw_if_index));
1006
1007     return (s);
1008 }
1009
1010 u8*
1011 format_adj_nbr (u8* s, va_list *ap)
1012 {
1013     index_t index = va_arg(*ap, index_t);
1014     CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
1015     ip_adjacency_t * adj = adj_get(index);
1016
1017     s = format (s, "%U", format_vnet_link, adj->ia_link);
1018     s = format (s, " via %U ",
1019                 format_ip46_address, &adj->sub_type.nbr.next_hop,
1020                 adj_proto_to_46(adj->ia_nh_proto));
1021     s = format (s, "%U",
1022                 format_vnet_rewrite,
1023                 &adj->rewrite_header, sizeof (adj->rewrite_data), 0);
1024
1025     return (s);
1026 }
1027
1028 static void
1029 adj_dpo_lock (dpo_id_t *dpo)
1030 {
1031     adj_lock(dpo->dpoi_index);
1032 }
1033 static void
1034 adj_dpo_unlock (dpo_id_t *dpo)
1035 {
1036     adj_unlock(dpo->dpoi_index);
1037 }
1038
1039 static void
1040 adj_mem_show (void)
1041 {
1042     fib_show_memory_usage("Adjacency",
1043                           pool_elts(adj_pool),
1044                           pool_len(adj_pool),
1045                           sizeof(ip_adjacency_t));
1046 }
1047
1048 const static dpo_vft_t adj_nbr_dpo_vft = {
1049     .dv_lock = adj_dpo_lock,
1050     .dv_unlock = adj_dpo_unlock,
1051     .dv_format = format_adj_nbr,
1052     .dv_mem_show = adj_mem_show,
1053 };
1054 const static dpo_vft_t adj_nbr_incompl_dpo_vft = {
1055     .dv_lock = adj_dpo_lock,
1056     .dv_unlock = adj_dpo_unlock,
1057     .dv_format = format_adj_nbr_incomplete,
1058 };
1059
1060 /**
1061  * @brief The per-protocol VLIB graph nodes that are assigned to an adjacency
1062  *        object.
1063  *
1064  * this means that these graph nodes are ones from which a nbr is the
1065  * parent object in the DPO-graph.
1066  */
1067 const static char* const nbr_ip4_nodes[] =
1068 {
1069     "ip4-rewrite",
1070     NULL,
1071 };
1072 const static char* const nbr_ip6_nodes[] =
1073 {
1074     "ip6-rewrite",
1075     NULL,
1076 };
1077 const static char* const nbr_mpls_nodes[] =
1078 {
1079     "mpls-output",
1080     NULL,
1081 };
1082 const static char* const nbr_ethernet_nodes[] =
1083 {
1084     "adj-l2-rewrite",
1085     NULL,
1086 };
1087 const static char* const * const nbr_nodes[DPO_PROTO_NUM] =
1088 {
1089     [DPO_PROTO_IP4]  = nbr_ip4_nodes,
1090     [DPO_PROTO_IP6]  = nbr_ip6_nodes,
1091     [DPO_PROTO_MPLS] = nbr_mpls_nodes,
1092     [DPO_PROTO_ETHERNET] = nbr_ethernet_nodes,
1093 };
1094
1095 const static char* const nbr_incomplete_ip4_nodes[] =
1096 {
1097     "ip4-arp",
1098     NULL,
1099 };
1100 const static char* const nbr_incomplete_ip6_nodes[] =
1101 {
1102     "ip6-discover-neighbor",
1103     NULL,
1104 };
1105 const static char* const nbr_incomplete_mpls_nodes[] =
1106 {
1107     "mpls-adj-incomplete",
1108     NULL,
1109 };
1110
1111 const static char* const * const nbr_incomplete_nodes[DPO_PROTO_NUM] =
1112 {
1113     [DPO_PROTO_IP4]  = nbr_incomplete_ip4_nodes,
1114     [DPO_PROTO_IP6]  = nbr_incomplete_ip6_nodes,
1115     [DPO_PROTO_MPLS] = nbr_incomplete_mpls_nodes,
1116 };
1117
1118 void
1119 adj_nbr_module_init (void)
1120 {
1121     dpo_register(DPO_ADJACENCY,
1122                  &adj_nbr_dpo_vft,
1123                  nbr_nodes);
1124     dpo_register(DPO_ADJACENCY_INCOMPLETE,
1125                  &adj_nbr_incompl_dpo_vft,
1126                  nbr_incomplete_nodes);
1127 }