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