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