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