src/vnet/adj/adj_nbr.c

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