src/vnet/adj/adj.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.h>
  17 #include <vnet/adj/adj_internal.h>
  18 #include <vnet/adj/adj_glean.h>
  19 #include <vnet/adj/adj_midchain.h>
  20 #include <vnet/adj/adj_mcast.h>
  21 #include <vnet/adj/adj_delegate.h>
  22 #include <vnet/fib/fib_node_list.h>
  23 #include <vnet/fib/fib_walk.h>
  24
  25 /* Adjacency packet/byte counters indexed by adjacency index. */
  26 vlib_combined_counter_main_t adjacency_counters = {
  27     .name = "adjacency",
  28     .stat_segment_name = "/net/adjacency",
  29 };
  30
  31 /*
  32  * the single adj pool
  33  */
  34 ip_adjacency_t *adj_pool;
  35
  36 /**
  37  * @brief Global Config for enabling per-adjacency counters.
  38  * By default these are disabled.
  39  */
  40 int adj_per_adj_counters;
  41
  42 const ip46_address_t ADJ_BCAST_ADDR = {
  43     .ip6 = {
  44         .as_u64[0] = 0xffffffffffffffff,
  45         .as_u64[1] = 0xffffffffffffffff,
  46     },
  47 };
  48
  49 /**
  50  * Adj flag names
  51  */
  52 static const char *adj_attr_names[] = ADJ_ATTR_NAMES;
  53
  54 always_inline void
  55 adj_poison (ip_adjacency_t * adj)
  56 {
  57     if (CLIB_DEBUG > 0)
  58     {
  59         clib_memset (adj, 0xfe, sizeof (adj[0]));
  60     }
  61 }
  62
  63 ip_adjacency_t *
  64 adj_alloc (fib_protocol_t proto)
  65 {
  66     ip_adjacency_t *adj;
  67     u8 need_barrier_sync = 0;
  68     vlib_main_t *vm;
  69     vm = vlib_get_main();
  70
  71     ASSERT (vm->thread_index == 0);
  72
  73     pool_get_aligned_will_expand (adj_pool, need_barrier_sync,
  74                                   CLIB_CACHE_LINE_BYTES);
  75     /* If the adj_pool will expand, stop the parade. */
  76     if (need_barrier_sync)
  77         vlib_worker_thread_barrier_sync (vm);
  78
  79     pool_get_aligned(adj_pool, adj, CLIB_CACHE_LINE_BYTES);
  80
  81     adj_poison(adj);
  82
  83     /* Validate adjacency counters. */
  84     if (need_barrier_sync == 0)
  85     {
  86         /* If the adj counter pool will expand, stop the parade */
  87         need_barrier_sync = vlib_validate_combined_counter_will_expand
  88             (&adjacency_counters, adj_get_index (adj));
  89         if (need_barrier_sync)
  90             vlib_worker_thread_barrier_sync (vm);
  91     }
  92     vlib_validate_combined_counter(&adjacency_counters,
  93                                    adj_get_index(adj));
  94
  95     /* Make sure certain fields are always initialized. */
  96     vlib_zero_combined_counter(&adjacency_counters,
  97                                adj_get_index(adj));
  98     fib_node_init(&adj->ia_node,
  99                   FIB_NODE_TYPE_ADJ);
 100
 101     adj->ia_nh_proto = proto;
 102     adj->ia_flags = 0;
 103     adj->ia_cfg_index = 0;
 104     adj->rewrite_header.sw_if_index = ~0;
 105     adj->rewrite_header.flags = 0;
 106     adj->lookup_next_index = 0;
 107     adj->ia_delegates = NULL;
 108
 109     /* lest it become a midchain in the future */
 110     clib_memset(&adj->sub_type.midchain.next_dpo, 0,
 111            sizeof(adj->sub_type.midchain.next_dpo));
 112
 113     if (need_barrier_sync)
 114         vlib_worker_thread_barrier_release (vm);
 115
 116     return (adj);
 117 }
 118
 119 static int
 120 adj_index_is_special (adj_index_t adj_index)
 121 {
 122     if (ADJ_INDEX_INVALID == adj_index)
 123         return (!0);
 124
 125     return (0);
 126 }
 127
 128 u8*
 129 format_adj_flags (u8 * s, va_list * args)
 130 {
 131     adj_flags_t af;
 132     adj_attr_t at;
 133
 134     af = va_arg (*args, int);
 135
 136     if (ADJ_FLAG_NONE == af)
 137     {
 138         return (format(s, "None"));
 139     }
 140     FOR_EACH_ADJ_ATTR(at)
 141     {
 142         if (af & (1 << at))
 143         {
 144             s = format(s, "%s ", adj_attr_names[at]);
 145         }
 146     }
 147     return (s);
 148 }
 149
 150 /**
 151  * @brief Pretty print helper function for formatting specific adjacencies.
 152  * @param s - input string to format
 153  * @param args - other args passed to format function such as:
 154  *                 - vnet_main_t
 155  *                 - ip_lookup_main_t
 156  *                 - adj_index
 157  */
 158 u8 *
 159 format_ip_adjacency (u8 * s, va_list * args)
 160 {
 161     format_ip_adjacency_flags_t fiaf;
 162     ip_adjacency_t * adj;
 163     u32 adj_index;
 164
 165     adj_index = va_arg (*args, u32);
 166     fiaf = va_arg (*args, format_ip_adjacency_flags_t);
 167
 168     if (!adj_is_valid(adj_index))
 169       return format(s, "<invalid adjacency>");
 170
 171     adj = adj_get(adj_index);
 172
 173     switch (adj->lookup_next_index)
 174     {
 175     case IP_LOOKUP_NEXT_REWRITE:
 176     case IP_LOOKUP_NEXT_BCAST:
 177         s = format (s, "%U", format_adj_nbr, adj_index, 0);
 178         break;
 179     case IP_LOOKUP_NEXT_ARP:
 180         s = format (s, "%U", format_adj_nbr_incomplete, adj_index, 0);
 181         break;
 182     case IP_LOOKUP_NEXT_GLEAN:
 183         s = format (s, "%U", format_adj_glean, adj_index, 0);
 184         break;
 185     case IP_LOOKUP_NEXT_MIDCHAIN:
 186         s = format (s, "%U", format_adj_midchain, adj_index, 2);
 187         break;
 188     case IP_LOOKUP_NEXT_MCAST:
 189         s = format (s, "%U", format_adj_mcast, adj_index, 0);
 190         break;
 191     case IP_LOOKUP_NEXT_MCAST_MIDCHAIN:
 192         s = format (s, "%U", format_adj_mcast_midchain, adj_index, 0);
 193         break;
 194     case IP_LOOKUP_NEXT_DROP:
 195     case IP_LOOKUP_NEXT_PUNT:
 196     case IP_LOOKUP_NEXT_LOCAL:
 197     case IP_LOOKUP_NEXT_ICMP_ERROR:
 198     case IP_LOOKUP_N_NEXT:
 199         break;
 200     }
 201
 202     if (fiaf & FORMAT_IP_ADJACENCY_DETAIL)
 203     {
 204         vlib_counter_t counts;
 205
 206         vlib_get_combined_counter(&adjacency_counters, adj_index, &counts);
 207         s = format (s, "\n   flags:%U", format_adj_flags, adj->ia_flags);
 208         s = format (s, "\n   counts:[%Ld:%Ld]", counts.packets, counts.bytes);
 209         s = format (s, "\n   locks:%d", adj->ia_node.fn_locks);
 210         s = format(s, "\n delegates:");
 211         s = adj_delegate_format(s, adj);
 212
 213         s = format(s, "\n children:");
 214         if (fib_node_list_get_size(adj->ia_node.fn_children))
 215         {
 216             s = format(s, "\n  ");
 217             s = fib_node_children_format(adj->ia_node.fn_children, s);
 218         }
 219     }
 220
 221     return s;
 222 }
 223
 224 int
 225 adj_recursive_loop_detect (adj_index_t ai,
 226                            fib_node_index_t **entry_indicies)
 227 {
 228     ip_adjacency_t * adj;
 229
 230     adj = adj_get(ai);
 231
 232     switch (adj->lookup_next_index)
 233     {
 234     case IP_LOOKUP_NEXT_REWRITE:
 235     case IP_LOOKUP_NEXT_ARP:
 236     case IP_LOOKUP_NEXT_GLEAN:
 237     case IP_LOOKUP_NEXT_MCAST:
 238     case IP_LOOKUP_NEXT_BCAST:
 239     case IP_LOOKUP_NEXT_DROP:
 240     case IP_LOOKUP_NEXT_PUNT:
 241     case IP_LOOKUP_NEXT_LOCAL:
 242     case IP_LOOKUP_NEXT_ICMP_ERROR:
 243     case IP_LOOKUP_N_NEXT:
 244         /*
 245          * these adjacency types are terminal graph nodes, so there's no
 246          * possibility of a loop down here.
 247          */
 248         break;
 249     case IP_LOOKUP_NEXT_MIDCHAIN:
 250     case IP_LOOKUP_NEXT_MCAST_MIDCHAIN:
 251         return (adj_ndr_midchain_recursive_loop_detect(ai, entry_indicies));
 252     }
 253
 254     return (0);
 255 }
 256
 257 /*
 258  * adj_last_lock_gone
 259  *
 260  * last lock/reference to the adj has gone, we no longer need it.
 261  */
 262 static void
 263 adj_last_lock_gone (ip_adjacency_t *adj)
 264 {
 265     vlib_main_t * vm = vlib_get_main();
 266
 267     ASSERT(0 == fib_node_list_get_size(adj->ia_node.fn_children));
 268     ADJ_DBG(adj, "last-lock-gone");
 269
 270     adj_delegate_adj_deleted(adj);
 271
 272     vlib_worker_thread_barrier_sync (vm);
 273
 274     switch (adj->lookup_next_index)
 275     {
 276     case IP_LOOKUP_NEXT_MIDCHAIN:
 277         adj_midchain_teardown(adj);
 278         /* FALL THROUGH */
 279     case IP_LOOKUP_NEXT_ARP:
 280     case IP_LOOKUP_NEXT_REWRITE:
 281     case IP_LOOKUP_NEXT_BCAST:
 282         /*
 283          * complete and incomplete nbr adjs
 284          */
 285         adj_nbr_remove(adj_get_index(adj),
 286                        adj->ia_nh_proto,
 287                        adj->ia_link,
 288                        &adj->sub_type.nbr.next_hop,
 289                        adj->rewrite_header.sw_if_index);
 290         break;
 291     case IP_LOOKUP_NEXT_GLEAN:
 292         adj_glean_remove(adj);
 293         break;
 294     case IP_LOOKUP_NEXT_MCAST_MIDCHAIN:
 295         adj_midchain_teardown(adj);
 296         /* FALL THROUGH */
 297     case IP_LOOKUP_NEXT_MCAST:
 298         adj_mcast_remove(adj->ia_nh_proto,
 299                          adj->rewrite_header.sw_if_index);
 300         break;
 301     case IP_LOOKUP_NEXT_DROP:
 302     case IP_LOOKUP_NEXT_PUNT:
 303     case IP_LOOKUP_NEXT_LOCAL:
 304     case IP_LOOKUP_NEXT_ICMP_ERROR:
 305     case IP_LOOKUP_N_NEXT:
 306         /*
 307          * type not stored in any DB from which we need to remove it
 308          */
 309         break;
 310     }
 311
 312     vlib_worker_thread_barrier_release(vm);
 313
 314     fib_node_deinit(&adj->ia_node);
 315     ASSERT(0 == vec_len(adj->ia_delegates));
 316     vec_free(adj->ia_delegates);
 317     pool_put(adj_pool, adj);
 318 }
 319
 320 u32
 321 adj_dpo_get_urpf (const dpo_id_t *dpo)
 322 {
 323     ip_adjacency_t *adj;
 324
 325     adj = adj_get(dpo->dpoi_index);
 326
 327     return (adj->rewrite_header.sw_if_index);
 328 }
 329
 330 u16
 331 adj_dpo_get_mtu (const dpo_id_t *dpo)
 332 {
 333     ip_adjacency_t *adj;
 334
 335     adj = adj_get(dpo->dpoi_index);
 336
 337     return (adj->rewrite_header.max_l3_packet_bytes);
 338 }
 339
 340 void
 341 adj_lock (adj_index_t adj_index)
 342 {
 343     ip_adjacency_t *adj;
 344
 345     if (adj_index_is_special(adj_index))
 346     {
 347         return;
 348     }
 349
 350     adj = adj_get(adj_index);
 351     ASSERT(adj);
 352
 353     ADJ_DBG(adj, "lock");
 354     fib_node_lock(&adj->ia_node);
 355 }
 356
 357 void
 358 adj_unlock (adj_index_t adj_index)
 359 {
 360     ip_adjacency_t *adj;
 361
 362     if (adj_index_is_special(adj_index))
 363     {
 364         return;
 365     }
 366
 367     adj = adj_get(adj_index);
 368     ASSERT(adj);
 369
 370     ADJ_DBG(adj, "unlock");
 371     ASSERT(adj);
 372
 373     fib_node_unlock(&adj->ia_node);
 374 }
 375
 376 u32
 377 adj_child_add (adj_index_t adj_index,
 378                fib_node_type_t child_type,
 379                fib_node_index_t child_index)
 380 {
 381     ASSERT(ADJ_INDEX_INVALID != adj_index);
 382     if (adj_index_is_special(adj_index))
 383     {
 384         return (~0);
 385     }
 386
 387     return (fib_node_child_add(FIB_NODE_TYPE_ADJ,
 388                                adj_index,
 389                                child_type,
 390                                child_index));
 391 }
 392
 393 void
 394 adj_child_remove (adj_index_t adj_index,
 395                   u32 sibling_index)
 396 {
 397     if (adj_index_is_special(adj_index))
 398     {
 399         return;
 400     }
 401
 402     fib_node_child_remove(FIB_NODE_TYPE_ADJ,
 403                           adj_index,
 404                           sibling_index);
 405 }
 406
 407 /*
 408  * Context for the walk to update the cached feature flags.
 409  */
 410 typedef struct adj_feature_update_t_
 411 {
 412     u8 arc;
 413     u8 enable;
 414 } adj_feature_update_ctx_t;
 415
 416 static adj_walk_rc_t
 417 adj_feature_update_walk_cb (adj_index_t ai,
 418                             void *arg)
 419 {
 420     adj_feature_update_ctx_t *ctx = arg;
 421     ip_adjacency_t *adj;
 422
 423     adj = adj_get(ai);
 424
 425     /*
 426      * this ugly mess matches the feature arc that is changing with affected
 427      * adjacencies
 428      */
 429     if (((ctx->arc == ip6_main.lookup_main.output_feature_arc_index) &&
 430          (VNET_LINK_IP6 == adj->ia_link)) ||
 431         ((ctx->arc == ip4_main.lookup_main.output_feature_arc_index) &&
 432          (VNET_LINK_IP4 == adj->ia_link)) ||
 433         ((ctx->arc == mpls_main.output_feature_arc_index) &&
 434          (VNET_LINK_MPLS == adj->ia_link)))
 435     {
 436         vnet_feature_main_t *fm = &feature_main;
 437         vnet_feature_config_main_t *cm;
 438
 439         cm = &fm->feature_config_mains[ctx->arc];
 440
 441         if (ctx->enable)
 442             adj->rewrite_header.flags |= VNET_REWRITE_HAS_FEATURES;
 443         else
 444             adj->rewrite_header.flags &= ~VNET_REWRITE_HAS_FEATURES;
 445
 446         adj->ia_cfg_index = vec_elt (cm->config_index_by_sw_if_index,
 447                                      adj->rewrite_header.sw_if_index);
 448     }
 449     return (ADJ_WALK_RC_CONTINUE);
 450 }
 451
 452 static void
 453 adj_feature_update (u32 sw_if_index,
 454                     u8 arc_index,
 455                     u8 is_enable,
 456                     void *data)
 457 {
 458     /*
 459      * Walk all the adjacencies on the interface to update the cached
 460      * 'has-features' flag
 461      */
 462     adj_feature_update_ctx_t ctx = {
 463         .arc = arc_index,
 464         .enable = is_enable,
 465     };
 466     adj_walk (sw_if_index, adj_feature_update_walk_cb, &ctx);
 467 }
 468
 469 static adj_walk_rc_t
 470 adj_mtu_update_walk_cb (adj_index_t ai,
 471                         void *arg)
 472 {
 473     ip_adjacency_t *adj;
 474
 475     adj = adj_get(ai);
 476
 477     vnet_rewrite_update_mtu (vnet_get_main(), adj->ia_link,
 478                              &adj->rewrite_header);
 479     adj_delegate_adj_modified(adj);
 480
 481     /**
 482      * Backwalk to all Path MTU trackers, casual like ..
 483      */
 484     {
 485         fib_node_back_walk_ctx_t bw_ctx = {
 486             .fnbw_reason = FIB_NODE_BW_REASON_FLAG_ADJ_MTU,
 487         };
 488
 489         fib_walk_async(FIB_NODE_TYPE_ADJ, ai,
 490                        FIB_WALK_PRIORITY_LOW, &bw_ctx);
 491     }
 492
 493     return (ADJ_WALK_RC_CONTINUE);
 494 }
 495
 496 static clib_error_t *
 497 adj_mtu_update (vnet_main_t * vnm, u32 sw_if_index, u32 flags)
 498 {
 499   adj_walk (sw_if_index, adj_mtu_update_walk_cb, NULL);
 500
 501   return (NULL);
 502 }
 503
 504 VNET_SW_INTERFACE_MTU_CHANGE_FUNCTION(adj_mtu_update);
 505
 506 /**
 507  * @brief Walk the Adjacencies on a given interface
 508  */
 509 void
 510 adj_walk (u32 sw_if_index,
 511           adj_walk_cb_t cb,
 512           void *ctx)
 513 {
 514     /*
 515      * walk all the neighbor adjacencies
 516      */
 517     fib_protocol_t proto;
 518
 519     FOR_EACH_FIB_IP_PROTOCOL(proto)
 520     {
 521         adj_nbr_walk(sw_if_index, proto, cb, ctx);
 522         adj_mcast_walk(sw_if_index, proto, cb, ctx);
 523     }
 524 }
 525
 526 /**
 527  * @brief Return the link type of the adjacency
 528  */
 529 vnet_link_t
 530 adj_get_link_type (adj_index_t ai)
 531 {
 532     const ip_adjacency_t *adj;
 533
 534     adj = adj_get(ai);
 535
 536     return (adj->ia_link);
 537 }
 538
 539 /**
 540  * @brief Return the sw interface index of the adjacency.
 541  */
 542 u32
 543 adj_get_sw_if_index (adj_index_t ai)
 544 {
 545     const ip_adjacency_t *adj;
 546
 547     adj = adj_get(ai);
 548
 549     return (adj->rewrite_header.sw_if_index);
 550 }
 551
 552 /**
 553  * @brief Return true if the adjacency is 'UP', i.e. can be used for forwarding
 554  * 0 is down, !0 is up.
 555  */
 556 int
 557 adj_is_up (adj_index_t ai)
 558 {
 559     return (adj_bfd_is_up(ai));
 560 }
 561
 562 /**
 563  * @brief Return the rewrite string of the adjacency
 564  */
 565 const u8*
 566 adj_get_rewrite (adj_index_t ai)
 567 {
 568     vnet_rewrite_header_t *rw;
 569     ip_adjacency_t *adj;
 570
 571     adj = adj_get(ai);
 572     rw = &adj->rewrite_header;
 573
 574     ASSERT (rw->data_bytes != 0xfefe);
 575
 576     return (rw->data - rw->data_bytes);
 577 }
 578
 579 static fib_node_t *
 580 adj_get_node (fib_node_index_t index)
 581 {
 582     ip_adjacency_t *adj;
 583
 584     adj = adj_get(index);
 585
 586     return (&adj->ia_node);
 587 }
 588
 589 #define ADJ_FROM_NODE(_node)                                            \
 590     ((ip_adjacency_t*)((char*)_node - STRUCT_OFFSET_OF(ip_adjacency_t, ia_node)))
 591
 592 static void
 593 adj_node_last_lock_gone (fib_node_t *node)
 594 {
 595     adj_last_lock_gone(ADJ_FROM_NODE(node));
 596 }
 597
 598 static fib_node_back_walk_rc_t
 599 adj_back_walk_notify (fib_node_t *node,
 600                       fib_node_back_walk_ctx_t *ctx)
 601 {
 602     ip_adjacency_t *adj;
 603
 604     adj = ADJ_FROM_NODE(node);
 605
 606     switch (adj->lookup_next_index)
 607     {
 608     case IP_LOOKUP_NEXT_MIDCHAIN:
 609         adj_midchain_delegate_restack(adj_get_index(adj));
 610         break;
 611     case IP_LOOKUP_NEXT_ARP:
 612     case IP_LOOKUP_NEXT_REWRITE:
 613     case IP_LOOKUP_NEXT_BCAST:
 614     case IP_LOOKUP_NEXT_GLEAN:
 615     case IP_LOOKUP_NEXT_MCAST:
 616     case IP_LOOKUP_NEXT_MCAST_MIDCHAIN:
 617     case IP_LOOKUP_NEXT_DROP:
 618     case IP_LOOKUP_NEXT_PUNT:
 619     case IP_LOOKUP_NEXT_LOCAL:
 620     case IP_LOOKUP_NEXT_ICMP_ERROR:
 621     case IP_LOOKUP_N_NEXT:
 622         /*
 623          * Que pasa. yo soj en el final!
 624          */
 625         ASSERT(0);
 626         break;
 627     }
 628
 629     return (FIB_NODE_BACK_WALK_CONTINUE);
 630 }
 631
 632 /*
 633  * Adjacency's graph node virtual function table
 634  */
 635 static const fib_node_vft_t adj_vft = {
 636     .fnv_get = adj_get_node,
 637     .fnv_last_lock = adj_node_last_lock_gone,
 638     .fnv_back_walk = adj_back_walk_notify,
 639 };
 640
 641 static clib_error_t *
 642 adj_module_init (vlib_main_t * vm)
 643 {
 644     fib_node_register_type(FIB_NODE_TYPE_ADJ, &adj_vft);
 645
 646     adj_nbr_module_init();
 647     adj_glean_module_init();
 648     adj_midchain_module_init();
 649     adj_mcast_module_init();
 650
 651     vnet_feature_register(adj_feature_update, NULL);
 652
 653     return (NULL);
 654 }
 655
 656 VLIB_INIT_FUNCTION (adj_module_init);
 657
 658 static clib_error_t *
 659 adj_show (vlib_main_t * vm,
 660           unformat_input_t * input,
 661           vlib_cli_command_t * cmd)
 662 {
 663     adj_index_t ai = ADJ_INDEX_INVALID;
 664     u32 sw_if_index = ~0;
 665     int summary = 0;
 666
 667     while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 668     {
 669         if (unformat (input, "%d", &ai))
 670             ;
 671         else if (unformat (input, "summary") || unformat (input, "sum"))
 672             summary = 1;
 673         else if (unformat (input, "%U",
 674                            unformat_vnet_sw_interface, vnet_get_main(),
 675                            &sw_if_index))
 676             ;
 677         else
 678             break;
 679     }
 680
 681     if (summary)
 682     {
 683         vlib_cli_output (vm, "Number of adjacencies: %d", pool_elts(adj_pool));
 684         vlib_cli_output (vm, "Per-adjacency counters: %s",
 685                          (adj_are_counters_enabled() ?
 686                           "enabled":
 687                           "disabled"));
 688     }
 689     else
 690     {
 691         if (ADJ_INDEX_INVALID != ai)
 692         {
 693             if (pool_is_free_index(adj_pool, ai))
 694             {
 695                 vlib_cli_output (vm, "adjacency %d invalid", ai);
 696                 return 0;
 697             }
 698
 699             vlib_cli_output (vm, "[@%d] %U",
 700                              ai,
 701                              format_ip_adjacency,  ai,
 702                              FORMAT_IP_ADJACENCY_DETAIL);
 703         }
 704         else
 705         {
 706             /* *INDENT-OFF* */
 707             pool_foreach_index (ai, adj_pool)
 708              {
 709                 if (~0 != sw_if_index &&
 710                     sw_if_index != adj_get_sw_if_index(ai))
 711                 {
 712                 }
 713                 else
 714                 {
 715                     vlib_cli_output (vm, "[@%d] %U",
 716                                      ai,
 717                                      format_ip_adjacency, ai,
 718                                      FORMAT_IP_ADJACENCY_NONE);
 719                 }
 720             }
 721             /* *INDENT-ON* */
 722         }
 723     }
 724     return 0;
 725 }
 726
 727 /*?
 728  * Show all adjacencies.
 729  * @cliexpar
 730  * @cliexstart{sh adj}
 731  * [@0]
 732  * [@1]  glean: loop0
 733  * [@2] ipv4 via 1.0.0.2 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
 734  * [@3] mpls via 1.0.0.2 loop0: MPLS: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
 735  * [@4] ipv4 via 1.0.0.3 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
 736  * [@5] mpls via 1.0.0.3 loop0: MPLS: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
 737  * @cliexend
 738  ?*/
 739 VLIB_CLI_COMMAND (adj_show_command, static) = {
 740     .path = "show adj",
 741     .short_help = "show adj [<adj_index>] [interface] [summary]",
 742     .function = adj_show,
 743 };
 744
 745 /**
 746  * @brief CLI invoked function to enable/disable per-adj counters
 747  */
 748 static clib_error_t *
 749 adj_cli_counters_set (vlib_main_t * vm,
 750                       unformat_input_t * input,
 751                       vlib_cli_command_t * cmd)
 752 {
 753     clib_error_t *error = NULL;
 754     int enable = ~0;
 755
 756     while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 757     {
 758         if (unformat (input, "enable"))
 759             enable = 1;
 760         else if (unformat (input, "disable"))
 761             enable = 0;
 762         else
 763             break;
 764     }
 765
 766     if (enable != ~0)
 767     {
 768         /* user requested something sensible */
 769         adj_per_adj_counters = enable;
 770     }
 771     else
 772     {
 773         error = clib_error_return (0, "specify 'enable' or 'disable'");
 774     }
 775
 776     return (error);
 777 }
 778
 779 /*?
 780  * Enable/disable per-adjacency counters. This is optional because it comes
 781  * with a non-negligible performance cost.
 782  ?*/
 783 VLIB_CLI_COMMAND (adj_cli_counters_set_command, static) = {
 784     .path = "adjacency counters",
 785     .short_help = "adjacency counters [enable|disable]",
 786     .function = adj_cli_counters_set,
 787 };