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 = adj_get(ai);
 754
 755     adj->ia_flags |= ADJ_FLAG_SYNC_WALK_ACTIVE;
 756     fib_walk_sync(FIB_NODE_TYPE_ADJ, ai, &bw_ctx);
 757     adj->ia_flags &= ~ADJ_FLAG_SYNC_WALK_ACTIVE;
 758
 759     return (ADJ_WALK_RC_CONTINUE);
 760 }
 761
 762 /**
 763  * @brief Registered function for SW interface state changes
 764  */
 765 static clib_error_t *
 766 adj_nbr_sw_interface_state_change (vnet_main_t * vnm,
 767                                    u32 sw_if_index,
 768                                    u32 flags)
 769 {
 770     fib_protocol_t proto;
 771
 772     /*
 773      * walk each adj on the interface and trigger a walk from that adj
 774      */
 775     for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
 776     {
 777         adj_nbr_interface_state_change_ctx_t ctx = {
 778             .flags = ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ?
 779                       ADJ_NBR_INTERFACE_UP :
 780                       0),
 781         };
 782
 783         adj_nbr_walk(sw_if_index, proto,
 784                      adj_nbr_interface_state_change_one,
 785                      &ctx);
 786     }
 787
 788     return (NULL);
 789 }
 790
 791 VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION_PRIO(
 792     adj_nbr_sw_interface_state_change,
 793     VNET_ITF_FUNC_PRIORITY_HIGH);
 794
 795 /**
 796  * @brief Invoked on each SW interface of a HW interface when the
 797  * HW interface state changes
 798  */
 799 static walk_rc_t
 800 adj_nbr_hw_sw_interface_state_change (vnet_main_t * vnm,
 801                                       u32 sw_if_index,
 802                                       void *arg)
 803 {
 804     adj_nbr_interface_state_change_ctx_t *ctx = arg;
 805     fib_protocol_t proto;
 806
 807     /*
 808      * walk each adj on the interface and trigger a walk from that adj
 809      */
 810     for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
 811     {
 812         adj_nbr_walk(sw_if_index, proto,
 813                      adj_nbr_interface_state_change_one,
 814                      ctx);
 815     }
 816     return (WALK_CONTINUE);
 817 }
 818
 819 /**
 820  * @brief Registered callback for HW interface state changes
 821  */
 822 static clib_error_t *
 823 adj_nbr_hw_interface_state_change (vnet_main_t * vnm,
 824                                    u32 hw_if_index,
 825                                    u32 flags)
 826 {
 827     /*
 828      * walk SW interface on the HW
 829      */
 830     adj_nbr_interface_state_change_ctx_t ctx = {
 831         .flags = ((flags & VNET_HW_INTERFACE_FLAG_LINK_UP) ?
 832                   ADJ_NBR_INTERFACE_UP :
 833                   0),
 834     };
 835
 836     vnet_hw_interface_walk_sw(vnm, hw_if_index,
 837                               adj_nbr_hw_sw_interface_state_change,
 838                               &ctx);
 839
 840     return (NULL);
 841 }
 842
 843 VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION_PRIO(
 844     adj_nbr_hw_interface_state_change,
 845     VNET_ITF_FUNC_PRIORITY_HIGH);
 846
 847 static adj_walk_rc_t
 848 adj_nbr_interface_delete_one (adj_index_t ai,
 849                               void *arg)
 850 {
 851     /*
 852      * Back walk the graph to inform the forwarding entries
 853      * that this interface has been deleted.
 854      */
 855     fib_node_back_walk_ctx_t bw_ctx = {
 856         .fnbw_reason = FIB_NODE_BW_REASON_FLAG_INTERFACE_DELETE,
 857     };
 858     ip_adjacency_t *adj;
 859
 860     adj_lock(ai);
 861
 862     adj = adj_get(ai);
 863
 864     adj->ia_flags |= ADJ_FLAG_SYNC_WALK_ACTIVE;
 865     fib_walk_sync(FIB_NODE_TYPE_ADJ, ai, &bw_ctx);
 866     adj->ia_flags &= ~ADJ_FLAG_SYNC_WALK_ACTIVE;
 867
 868     adj_unlock(ai);
 869     return (ADJ_WALK_RC_CONTINUE);
 870 }
 871
 872 /**
 873  * adj_nbr_interface_add_del
 874  *
 875  * Registered to receive interface Add and delete notifications
 876  */
 877 static clib_error_t *
 878 adj_nbr_interface_add_del (vnet_main_t * vnm,
 879                            u32 sw_if_index,
 880                            u32 is_add)
 881 {
 882     fib_protocol_t proto;
 883
 884     if (is_add)
 885     {
 886         /*
 887          * not interested in interface additions. we will not back walk
 888          * to resolve paths through newly added interfaces. Why? The control
 889          * plane should have the brains to add interfaces first, then routes.
 890          * So the case where there are paths with a interface that matches
 891          * one just created is the case where the path resolved through an
 892          * interface that was deleted, and still has not been removed. The
 893          * new interface added, is NO GUARANTEE that the interface being
 894          * added now, even though it may have the same sw_if_index, is the
 895          * same interface that the path needs. So tough!
 896          * If the control plane wants these routes to resolve it needs to
 897          * remove and add them again.
 898          */
 899         return (NULL);
 900     }
 901
 902     for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
 903     {
 904         adj_nbr_walk(sw_if_index, proto,
 905                      adj_nbr_interface_delete_one,
 906                      NULL);
 907     }
 908
 909     return (NULL);
 910
 911 }
 912
 913 VNET_SW_INTERFACE_ADD_DEL_FUNCTION(adj_nbr_interface_add_del);
 914
 915
 916 static adj_walk_rc_t
 917 adj_nbr_show_one (adj_index_t ai,
 918                   void *arg)
 919 {
 920     vlib_cli_output (arg, "[@%d]  %U",
 921                      ai,
 922                      format_ip_adjacency, ai,
 923                      FORMAT_IP_ADJACENCY_NONE);
 924
 925     return (ADJ_WALK_RC_CONTINUE);
 926 }
 927
 928 static clib_error_t *
 929 adj_nbr_show (vlib_main_t * vm,
 930               unformat_input_t * input,
 931               vlib_cli_command_t * cmd)
 932 {
 933     adj_index_t ai = ADJ_INDEX_INVALID;
 934     ip46_address_t nh = ip46_address_initializer;
 935     u32 sw_if_index = ~0;
 936
 937     while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 938     {
 939         if (unformat (input, "%U",
 940                       unformat_vnet_sw_interface, vnet_get_main(),
 941                       &sw_if_index))
 942             ;
 943         else if (unformat (input, "%U",
 944                            unformat_ip46_address, &nh, IP46_TYPE_ANY))
 945             ;
 946         else if (unformat (input, "%d", &ai))
 947             ;
 948         else
 949             break;
 950     }
 951
 952     if (ADJ_INDEX_INVALID != ai)
 953     {
 954         vlib_cli_output (vm, "[@%d] %U",
 955                          ai,
 956                          format_ip_adjacency, ai,
 957                          FORMAT_IP_ADJACENCY_DETAIL);
 958     }
 959     else if (~0 != sw_if_index)
 960     {
 961         fib_protocol_t proto;
 962
 963         if (ip46_address_is_zero(&nh))
 964         {
 965             for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
 966             {
 967                 adj_nbr_walk(sw_if_index, proto,
 968                              adj_nbr_show_one,
 969                              vm);
 970             }
 971         }
 972         else
 973         {
 974             proto = (ip46_address_is_ip4(&nh) ?
 975                      FIB_PROTOCOL_IP4 :
 976                      FIB_PROTOCOL_IP6);
 977             adj_nbr_walk_nh(sw_if_index, proto, &nh,
 978                             adj_nbr_show_one,
 979                             vm);
 980         }
 981     }
 982     else
 983     {
 984         fib_protocol_t proto;
 985
 986         for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
 987         {
 988             vec_foreach_index(sw_if_index, adj_nbr_tables[proto])
 989             {
 990                 adj_nbr_walk(sw_if_index, proto,
 991                              adj_nbr_show_one,
 992                              vm);
 993             }
 994         }
 995     }
 996
 997     return 0;
 998 }
 999
1000 /*?
1001  * Show all neighbour adjacencies.
1002  * @cliexpar
1003  * @cliexstart{sh adj nbr}
1004  * [@2] ipv4 via 1.0.0.2 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
1005  * [@3] mpls via 1.0.0.2 loop0: MPLS_UNICAST: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
1006  * [@4] ipv4 via 1.0.0.3 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
1007  * [@5] mpls via 1.0.0.3 loop0: MPLS_UNICAST: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
1008  * @cliexend
1009  ?*/
1010 VLIB_CLI_COMMAND (ip4_show_fib_command, static) = {
1011     .path = "show adj nbr",
1012     .short_help = "show adj nbr [<adj_index>] [interface]",
1013     .function = adj_nbr_show,
1014 };
1015
1016 u8*
1017 format_adj_nbr_incomplete (u8* s, va_list *ap)
1018 {
1019     index_t index = va_arg(*ap, index_t);
1020     CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
1021     vnet_main_t * vnm = vnet_get_main();
1022     ip_adjacency_t * adj = adj_get(index);
1023
1024     s = format (s, "arp-%U", format_vnet_link, adj->ia_link);
1025     s = format (s, ": via %U",
1026                 format_ip46_address, &adj->sub_type.nbr.next_hop,
1027                 adj_proto_to_46(adj->ia_nh_proto));
1028     s = format (s, " %U",
1029                 format_vnet_sw_if_index_name,
1030                 vnm, adj->rewrite_header.sw_if_index);
1031
1032     return (s);
1033 }
1034
1035 u8*
1036 format_adj_nbr (u8* s, va_list *ap)
1037 {
1038     index_t index = va_arg(*ap, index_t);
1039     CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
1040     ip_adjacency_t * adj = adj_get(index);
1041
1042     s = format (s, "%U", format_vnet_link, adj->ia_link);
1043     s = format (s, " via %U ",
1044                 format_ip46_address, &adj->sub_type.nbr.next_hop,
1045                 adj_proto_to_46(adj->ia_nh_proto));
1046     s = format (s, "%U",
1047                 format_vnet_rewrite,
1048                 &adj->rewrite_header, sizeof (adj->rewrite_data), 0);
1049
1050     return (s);
1051 }
1052
1053 static void
1054 adj_dpo_lock (dpo_id_t *dpo)
1055 {
1056     adj_lock(dpo->dpoi_index);
1057 }
1058 static void
1059 adj_dpo_unlock (dpo_id_t *dpo)
1060 {
1061     adj_unlock(dpo->dpoi_index);
1062 }
1063
1064 static void
1065 adj_mem_show (void)
1066 {
1067     fib_show_memory_usage("Adjacency",
1068                           pool_elts(adj_pool),
1069                           pool_len(adj_pool),
1070                           sizeof(ip_adjacency_t));
1071 }
1072
1073 const static dpo_vft_t adj_nbr_dpo_vft = {
1074     .dv_lock = adj_dpo_lock,
1075     .dv_unlock = adj_dpo_unlock,
1076     .dv_format = format_adj_nbr,
1077     .dv_mem_show = adj_mem_show,
1078     .dv_get_urpf = adj_dpo_get_urpf,
1079     .dv_get_mtu = adj_dpo_get_mtu,
1080 };
1081 const static dpo_vft_t adj_nbr_incompl_dpo_vft = {
1082     .dv_lock = adj_dpo_lock,
1083     .dv_unlock = adj_dpo_unlock,
1084     .dv_format = format_adj_nbr_incomplete,
1085     .dv_get_urpf = adj_dpo_get_urpf,
1086     .dv_get_mtu = adj_dpo_get_mtu,
1087 };
1088
1089 /**
1090  * @brief The per-protocol VLIB graph nodes that are assigned to an adjacency
1091  *        object.
1092  *
1093  * this means that these graph nodes are ones from which a nbr is the
1094  * parent object in the DPO-graph.
1095  */
1096 const static char* const nbr_ip4_nodes[] =
1097 {
1098     "ip4-rewrite",
1099     NULL,
1100 };
1101 const static char* const nbr_ip6_nodes[] =
1102 {
1103     "ip6-rewrite",
1104     NULL,
1105 };
1106 const static char* const nbr_mpls_nodes[] =
1107 {
1108     "mpls-output",
1109     NULL,
1110 };
1111 const static char* const nbr_ethernet_nodes[] =
1112 {
1113     "adj-l2-rewrite",
1114     NULL,
1115 };
1116 const static char* const * const nbr_nodes[DPO_PROTO_NUM] =
1117 {
1118     [DPO_PROTO_IP4]  = nbr_ip4_nodes,
1119     [DPO_PROTO_IP6]  = nbr_ip6_nodes,
1120     [DPO_PROTO_MPLS] = nbr_mpls_nodes,
1121     [DPO_PROTO_ETHERNET] = nbr_ethernet_nodes,
1122 };
1123
1124 const static char* const nbr_incomplete_ip4_nodes[] =
1125 {
1126     "ip4-arp",
1127     NULL,
1128 };
1129 const static char* const nbr_incomplete_ip6_nodes[] =
1130 {
1131     "ip6-discover-neighbor",
1132     NULL,
1133 };
1134 const static char* const nbr_incomplete_mpls_nodes[] =
1135 {
1136     "mpls-adj-incomplete",
1137     NULL,
1138 };
1139
1140 const static char* const * const nbr_incomplete_nodes[DPO_PROTO_NUM] =
1141 {
1142     [DPO_PROTO_IP4]  = nbr_incomplete_ip4_nodes,
1143     [DPO_PROTO_IP6]  = nbr_incomplete_ip6_nodes,
1144     [DPO_PROTO_MPLS] = nbr_incomplete_mpls_nodes,
1145 };
1146
1147 void
1148 adj_nbr_module_init (void)
1149 {
1150     dpo_register(DPO_ADJACENCY,
1151                  &adj_nbr_dpo_vft,
1152                  nbr_nodes);
1153     dpo_register(DPO_ADJACENCY_INCOMPLETE,
1154                  &adj_nbr_incompl_dpo_vft,
1155                  nbr_incomplete_nodes);
1156 }