vnet/vnet/mpls/mpls_tunnel.c

   1 /*
   2  * mpls_tunnel.c: MPLS tunnel interfaces (i.e. for RSVP-TE)
   3  *
   4  * Copyright (c) 2012 Cisco and/or its affiliates.
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <vnet/vnet.h>
  19 #include <vnet/pg/pg.h>
  20 #include <vnet/mpls/mpls_tunnel.h>
  21 #include <vnet/ip/ip.h>
  22 #include <vnet/fib/fib_path_list.h>
  23 #include <vnet/adj/adj_midchain.h>
  24
  25 /**
  26  * @brief pool of tunnel instances
  27  */
  28 static mpls_tunnel_t *mpls_tunnel_pool;
  29
  30 /**
  31  * @brief Pool of free tunnel SW indices - i.e. recycled indices
  32  */
  33 static u32 * mpls_tunnel_free_hw_if_indices;
  34
  35 /**
  36  * @brief DB of SW index to tunnel index
  37  */
  38 static u32 *mpls_tunnel_db;
  39
  40 /**
  41  * @brief Get a tunnel object from a SW interface index
  42  */
  43 static mpls_tunnel_t*
  44 mpls_tunnel_get_from_sw_if_index (u32 sw_if_index)
  45 {
  46     if ((vec_len(mpls_tunnel_db) < sw_if_index) ||
  47         (~0 == mpls_tunnel_db[sw_if_index]))
  48         return (NULL);
  49
  50     return (pool_elt_at_index(mpls_tunnel_pool,
  51                               mpls_tunnel_db[sw_if_index]));
  52 }
  53
  54 /**
  55  * @brief Return true if the label stack is imp-null only
  56  */
  57 static fib_forward_chain_type_t
  58 mpls_tunnel_get_fwd_chain_type (const mpls_tunnel_t *mt)
  59 {
  60     if ((1 == vec_len(mt->mt_label_stack)) &&
  61         (mt->mt_label_stack[0] == MPLS_IETF_IMPLICIT_NULL_LABEL))
  62     {
  63         /*
  64          * the only label in the label stack is implicit null
  65          * we need to build an IP chain.
  66          */
  67         if (FIB_PROTOCOL_IP4 == fib_path_list_get_proto(mt->mt_path_list))
  68         {
  69             return (FIB_FORW_CHAIN_TYPE_UNICAST_IP4);
  70         }
  71         else
  72         {
  73             return (FIB_FORW_CHAIN_TYPE_UNICAST_IP6);
  74         }
  75     }
  76     else
  77     {
  78         return (FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS);
  79     }
  80 }
  81
  82 /**
  83  * @brief Build a rewrite string for the MPLS tunnel.
  84  *
  85  * We have choices here;
  86  *  1 - have an Adjacency with a zero length string and stack it on
  87  *       MPLS label objects
  88  *  2 - put the label header rewrites in the adjacency string.
  89  *
  90  * We choose 2 since it results in fewer graph nodes in the egress path
  91  */
  92 static u8*
  93 mpls_tunnel_build_rewrite (vnet_main_t * vnm,
  94                            u32 sw_if_index,
  95                            vnet_link_t link_type,
  96                            const void *dst_address)
  97 {
  98     mpls_unicast_header_t *muh;
  99     mpls_tunnel_t *mt;
 100     u8 *rewrite;
 101     u32 mti, ii;
 102
 103     rewrite = NULL;
 104     mti = mpls_tunnel_db[sw_if_index];
 105     mt = pool_elt_at_index(mpls_tunnel_pool, mti);
 106
 107     /*
 108      * The vector must be allocated as u8 so the length is correct
 109      */
 110     ASSERT(0 < vec_len(mt->mt_label_stack));
 111     vec_validate(rewrite, (sizeof(*muh) * vec_len(mt->mt_label_stack)) - 1);
 112     ASSERT(rewrite);
 113     muh = (mpls_unicast_header_t *)rewrite;
 114
 115     /*
 116      * The last (inner most) label in the stack may be EOS, all the rest Non-EOS
 117      */
 118     for (ii = 0; ii < vec_len(mt->mt_label_stack)-1; ii++)
 119     {
 120         vnet_mpls_uc_set_label(&muh[ii].label_exp_s_ttl, mt->mt_label_stack[ii]);
 121         vnet_mpls_uc_set_ttl(&muh[ii].label_exp_s_ttl, 255);
 122         vnet_mpls_uc_set_exp(&muh[ii].label_exp_s_ttl, 0);
 123         vnet_mpls_uc_set_s(&muh[ii].label_exp_s_ttl, MPLS_NON_EOS);
 124         muh[ii].label_exp_s_ttl = clib_host_to_net_u32(muh[ii].label_exp_s_ttl);
 125     }
 126
 127     vnet_mpls_uc_set_label(&muh[ii].label_exp_s_ttl, mt->mt_label_stack[ii]);
 128     vnet_mpls_uc_set_ttl(&muh[ii].label_exp_s_ttl, 255);
 129     vnet_mpls_uc_set_exp(&muh[ii].label_exp_s_ttl, 0);
 130
 131     if ((VNET_LINK_MPLS == link_type) &&
 132         (mt->mt_label_stack[ii] != MPLS_IETF_IMPLICIT_NULL_LABEL))
 133     {
 134         vnet_mpls_uc_set_s(&muh[ii].label_exp_s_ttl, MPLS_NON_EOS);
 135     }
 136     else
 137     {
 138         vnet_mpls_uc_set_s(&muh[ii].label_exp_s_ttl, MPLS_EOS);
 139     }
 140
 141     muh[ii].label_exp_s_ttl = clib_host_to_net_u32(muh[ii].label_exp_s_ttl);
 142
 143     return (rewrite);
 144 }
 145
 146 /**
 147  * mpls_tunnel_stack
 148  *
 149  * 'stack' (resolve the recursion for) the tunnel's midchain adjacency
 150  */
 151 static void
 152 mpls_tunnel_stack (adj_index_t ai)
 153 {
 154     ip_adjacency_t *adj;
 155     mpls_tunnel_t *mt;
 156     u32 sw_if_index;
 157
 158     adj = adj_get(ai);
 159     sw_if_index = adj->rewrite_header.sw_if_index;
 160
 161     mt = mpls_tunnel_get_from_sw_if_index(sw_if_index);
 162
 163     if (NULL == mt)
 164         return;
 165
 166     /*
 167      * find the adjacency that is contributed by the FIB path-list
 168      * that this tunnel resovles via, and use it as the next adj
 169      * in the midchain
 170      */
 171     if (vnet_hw_interface_get_flags(vnet_get_main(),
 172                                     mt->mt_hw_if_index) &
 173         VNET_HW_INTERFACE_FLAG_LINK_UP)
 174     {
 175         dpo_id_t dpo = DPO_INVALID;
 176
 177         fib_path_list_contribute_forwarding(mt->mt_path_list,
 178                                             mpls_tunnel_get_fwd_chain_type(mt),
 179                                             &dpo);
 180
 181         if (DPO_LOAD_BALANCE == dpo.dpoi_type)
 182         {
 183             /*
 184              * we don't support multiple paths, so no need to load-balance.
 185              * pull the first and only choice and stack directly on that.
 186              */
 187             load_balance_t *lb;
 188
 189             lb = load_balance_get (dpo.dpoi_index);
 190
 191             ASSERT(1 == lb->lb_n_buckets);
 192
 193             dpo_copy(&dpo, load_balance_get_bucket_i (lb, 0));
 194         }
 195
 196         adj_nbr_midchain_stack(ai, &dpo);
 197         dpo_reset(&dpo);
 198     }
 199     else
 200     {
 201         adj_nbr_midchain_unstack(ai);
 202     }
 203 }
 204
 205 /**
 206  * @brief Call back when restacking all adjacencies on a MPLS interface
 207  */
 208 static adj_walk_rc_t
 209 mpls_adj_walk_cb (adj_index_t ai,
 210                  void *ctx)
 211 {
 212     mpls_tunnel_stack(ai);
 213
 214     return (ADJ_WALK_RC_CONTINUE);
 215 }
 216
 217 static void
 218 mpls_tunnel_restack (mpls_tunnel_t *mt)
 219 {
 220     fib_protocol_t proto;
 221
 222     /*
 223      * walk all the adjacencies on the MPLS interface and restack them
 224      */
 225     FOR_EACH_FIB_PROTOCOL(proto)
 226     {
 227         adj_nbr_walk(mt->mt_sw_if_index,
 228                      proto,
 229                      mpls_adj_walk_cb,
 230                      NULL);
 231     }
 232 }
 233
 234 static clib_error_t *
 235 mpls_tunnel_admin_up_down (vnet_main_t * vnm,
 236                            u32 hw_if_index,
 237                            u32 flags)
 238 {
 239     vnet_hw_interface_t * hi;
 240     mpls_tunnel_t *mt;
 241
 242     hi = vnet_get_hw_interface (vnm, hw_if_index);
 243
 244     mt = mpls_tunnel_get_from_sw_if_index(hi->sw_if_index);
 245
 246     if (NULL == mt)
 247         return (NULL);
 248
 249     if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
 250         vnet_hw_interface_set_flags (vnm, hw_if_index,
 251                                      VNET_HW_INTERFACE_FLAG_LINK_UP);
 252     else
 253         vnet_hw_interface_set_flags (vnm, hw_if_index, 0 /* down */);
 254
 255     mpls_tunnel_restack(mt);
 256
 257     return (NULL);
 258 }
 259
 260 /**
 261  * @brief Fixup the adj rewrite post encap. This is a no-op since the
 262  * rewrite is a stack of labels.
 263  */
 264 static void
 265 mpls_tunnel_fixup (vlib_main_t *vm,
 266                    ip_adjacency_t *adj,
 267                    vlib_buffer_t *b0)
 268 {
 269 }
 270
 271 static void
 272 mpls_tunnel_update_adj (vnet_main_t * vnm,
 273                         u32 sw_if_index,
 274                         adj_index_t ai)
 275 {
 276     adj_nbr_midchain_update_rewrite(
 277         ai, mpls_tunnel_fixup,
 278         ADJ_MIDCHAIN_FLAG_NONE,
 279         mpls_tunnel_build_rewrite(vnm, sw_if_index,
 280                                   adj_get_link_type(ai),
 281                                   NULL));
 282
 283     mpls_tunnel_stack(ai);
 284 }
 285
 286 static u8 *
 287 format_mpls_tunnel_name (u8 * s, va_list * args)
 288 {
 289   u32 dev_instance = va_arg (*args, u32);
 290   return format (s, "mpls-tunnel%d", dev_instance);
 291 }
 292
 293 static u8 *
 294 format_mpls_tunnel_device (u8 * s, va_list * args)
 295 {
 296   u32 dev_instance = va_arg (*args, u32);
 297   CLIB_UNUSED (int verbose) = va_arg (*args, int);
 298
 299   return (format (s, "MPLS-tunnel: id %d\n", dev_instance));
 300 }
 301
 302 /**
 303  * @brief Packet trace structure
 304  */
 305 typedef struct mpls_tunnel_trace_t_
 306 {
 307     /**
 308    * Tunnel-id / index in tunnel vector
 309    */
 310   u32 tunnel_id;
 311 } mpls_tunnel_trace_t;
 312
 313 static u8 *
 314 format_mpls_tunnel_tx_trace (u8 * s,
 315                              va_list * args)
 316 {
 317   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
 318   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
 319   mpls_tunnel_trace_t * t = va_arg (*args, mpls_tunnel_trace_t *);
 320
 321   s = format (s, "MPLS: tunnel %d", t->tunnel_id);
 322   return s;
 323 }
 324
 325 /**
 326  * @brief TX function. Only called L2. L3 traffic uses the adj-midchains
 327  */
 328 static uword
 329 mpls_tunnel_tx (vlib_main_t * vm,
 330                 vlib_node_runtime_t * node,
 331                 vlib_frame_t * frame)
 332 {
 333   u32 next_index;
 334   u32 * from, * to_next, n_left_from, n_left_to_next;
 335   vnet_interface_output_runtime_t * rd = (void *) node->runtime_data;
 336   const mpls_tunnel_t *mt;
 337
 338   mt = pool_elt_at_index(mpls_tunnel_pool, rd->dev_instance);
 339
 340   /* Vector of buffer / pkt indices we're supposed to process */
 341   from = vlib_frame_vector_args (frame);
 342
 343   /* Number of buffers / pkts */
 344   n_left_from = frame->n_vectors;
 345
 346   /* Speculatively send the first buffer to the last disposition we used */
 347   next_index = node->cached_next_index;
 348
 349   while (n_left_from > 0)
 350     {
 351       /* set up to enqueue to our disposition with index = next_index */
 352       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 353
 354       /*
 355        * FIXME DUAL LOOP
 356        */
 357       while (n_left_from > 0 && n_left_to_next > 0)
 358         {
 359           vlib_buffer_t * b0;
 360           u32 bi0;
 361
 362           bi0 = from[0];
 363           to_next[0] = bi0;
 364           from += 1;
 365           to_next += 1;
 366           n_left_from -= 1;
 367           n_left_to_next -= 1;
 368
 369           b0 = vlib_get_buffer(vm, bi0);
 370
 371           vnet_buffer(b0)->ip.adj_index[VLIB_TX] = mt->mt_l2_adj;
 372
 373           if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
 374             {
 375               mpls_tunnel_trace_t *tr = vlib_add_trace (vm, node,
 376                                                    b0, sizeof (*tr));
 377               tr->tunnel_id = rd->dev_instance;
 378             }
 379
 380           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 381                                            to_next, n_left_to_next,
 382                                            bi0, mt->mt_l2_tx_arc);
 383         }
 384
 385       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 386     }
 387
 388   return frame->n_vectors;
 389 }
 390
 391 VNET_DEVICE_CLASS (mpls_tunnel_class) = {
 392     .name = "MPLS tunnel device",
 393     .format_device_name = format_mpls_tunnel_name,
 394     .format_device = format_mpls_tunnel_device,
 395     .format_tx_trace = format_mpls_tunnel_tx_trace,
 396     .tx_function = mpls_tunnel_tx,
 397     .admin_up_down_function = mpls_tunnel_admin_up_down,
 398 };
 399
 400 VNET_HW_INTERFACE_CLASS (mpls_tunnel_hw_interface_class) = {
 401   .name = "MPLS-Tunnel",
 402 //  .format_header = format_mpls_eth_header_with_length,
 403 //  .unformat_header = unformat_mpls_eth_header,
 404   .update_adjacency = mpls_tunnel_update_adj,
 405   .build_rewrite = mpls_tunnel_build_rewrite,
 406   .flags = VNET_HW_INTERFACE_CLASS_FLAG_P2P,
 407 };
 408
 409 const mpls_tunnel_t *
 410 mpls_tunnel_get (u32 mti)
 411 {
 412     return (pool_elt_at_index(mpls_tunnel_pool, mti));
 413 }
 414
 415 /**
 416  * @brief Walk all the MPLS tunnels
 417  */
 418 void
 419 mpls_tunnel_walk (mpls_tunnel_walk_cb_t cb,
 420                   void *ctx)
 421 {
 422     u32 mti;
 423
 424     pool_foreach_index(mti, mpls_tunnel_pool,
 425     ({
 426         cb(mti, ctx);
 427     }));
 428 }
 429
 430 void
 431 vnet_mpls_tunnel_del (u32 sw_if_index)
 432 {
 433     mpls_tunnel_t *mt;
 434
 435     mt = mpls_tunnel_get_from_sw_if_index(sw_if_index);
 436
 437     if (NULL == mt)
 438         return;
 439
 440     fib_path_list_child_remove(mt->mt_path_list,
 441                                mt->mt_sibling_index);
 442     if (ADJ_INDEX_INVALID != mt->mt_l2_adj)
 443         adj_unlock(mt->mt_l2_adj);
 444
 445     vec_free(mt->mt_label_stack);
 446
 447     vec_add1 (mpls_tunnel_free_hw_if_indices, mt->mt_hw_if_index);
 448     pool_put(mpls_tunnel_pool, mt);
 449     mpls_tunnel_db[sw_if_index] = ~0;
 450 }
 451
 452 void
 453 vnet_mpls_tunnel_add (fib_route_path_t *rpaths,
 454                       mpls_label_t *label_stack,
 455                       u8 l2_only,
 456                       u32 *sw_if_index)
 457 {
 458     vnet_hw_interface_t * hi;
 459     mpls_tunnel_t *mt;
 460     vnet_main_t * vnm;
 461     u32 mti;
 462
 463     vnm = vnet_get_main();
 464     pool_get(mpls_tunnel_pool, mt);
 465     memset (mt, 0, sizeof (*mt));
 466     mti = mt - mpls_tunnel_pool;
 467     fib_node_init(&mt->mt_node, FIB_NODE_TYPE_MPLS_TUNNEL);
 468     mt->mt_l2_adj = ADJ_INDEX_INVALID;
 469
 470     /*
 471      * Create a new, or re=use and old, tunnel HW interface
 472      */
 473     if (vec_len (mpls_tunnel_free_hw_if_indices) > 0)
 474     {
 475         mt->mt_hw_if_index =
 476             mpls_tunnel_free_hw_if_indices[vec_len(mpls_tunnel_free_hw_if_indices)-1];
 477         _vec_len (mpls_tunnel_free_hw_if_indices) -= 1;
 478         hi = vnet_get_hw_interface (vnm, mt->mt_hw_if_index);
 479         hi->hw_instance = mti;
 480         hi->dev_instance = mti;
 481     }
 482     else
 483     {
 484         mt->mt_hw_if_index = vnet_register_interface(
 485                                  vnm,
 486                                  mpls_tunnel_class.index,
 487                                  mti,
 488                                  mpls_tunnel_hw_interface_class.index,
 489                                  mti);
 490         hi = vnet_get_hw_interface(vnm, mt->mt_hw_if_index);
 491     }
 492
 493     /*
 494      * Add the new tunnel to the tunnel DB - key:SW if index
 495      */
 496     mt->mt_sw_if_index = hi->sw_if_index;
 497     vec_validate_init_empty(mpls_tunnel_db, mt->mt_sw_if_index, ~0);
 498     mpls_tunnel_db[mt->mt_sw_if_index] = mti;
 499
 500     /*
 501      * construct a path-list from the path provided
 502      */
 503     mt->mt_path_list = fib_path_list_create(FIB_PATH_LIST_FLAG_SHARED, rpaths);
 504     mt->mt_sibling_index = fib_path_list_child_add(mt->mt_path_list,
 505                                                    FIB_NODE_TYPE_MPLS_TUNNEL,
 506                                                    mti);
 507
 508     mt->mt_label_stack = vec_dup(label_stack);
 509
 510     if (l2_only)
 511     {
 512         mt->mt_l2_adj =
 513             adj_nbr_add_or_lock(fib_path_list_get_proto(mt->mt_path_list),
 514                                 VNET_LINK_ETHERNET,
 515                                 &zero_addr,
 516                                 mt->mt_sw_if_index);
 517
 518         mt->mt_l2_tx_arc = vlib_node_add_named_next(vlib_get_main(),
 519                                                     hi->tx_node_index,
 520                                                     "adj-l2-midchain");
 521     }
 522
 523     *sw_if_index = mt->mt_sw_if_index;
 524 }
 525
 526 static clib_error_t *
 527 vnet_create_mpls_tunnel_command_fn (vlib_main_t * vm,
 528                                     unformat_input_t * input,
 529                                     vlib_cli_command_t * cmd)
 530 {
 531     unformat_input_t _line_input, * line_input = &_line_input;
 532     vnet_main_t * vnm = vnet_get_main();
 533     u8 is_del = 0;
 534     u8 l2_only = 0;
 535     fib_route_path_t rpath, *rpaths = NULL;
 536     mpls_label_t out_label = MPLS_LABEL_INVALID, *labels = NULL;
 537     u32 sw_if_index;
 538
 539     memset(&rpath, 0, sizeof(rpath));
 540
 541     /* Get a line of input. */
 542     if (! unformat_user (input, unformat_line_input, line_input))
 543         return 0;
 544
 545     while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 546     {
 547         if (unformat (line_input, "del %U",
 548                       unformat_vnet_sw_interface, vnm,
 549                       &sw_if_index))
 550             is_del = 1;
 551         else if (unformat (line_input, "add"))
 552             is_del = 0;
 553         else if (unformat (line_input, "out-label %U",
 554                            unformat_mpls_unicast_label, &out_label))
 555         {
 556             vec_add1(labels, out_label);
 557         }
 558         else if (unformat (line_input, "via %U %U",
 559                            unformat_ip4_address,
 560                            &rpath.frp_addr.ip4,
 561                            unformat_vnet_sw_interface, vnm,
 562                            &rpath.frp_sw_if_index))
 563         {
 564             rpath.frp_weight = 1;
 565             rpath.frp_proto = FIB_PROTOCOL_IP4;
 566         }
 567
 568         else if (unformat (line_input, "via %U %U",
 569                            unformat_ip6_address,
 570                            &rpath.frp_addr.ip6,
 571                            unformat_vnet_sw_interface, vnm,
 572                            &rpath.frp_sw_if_index))
 573         {
 574             rpath.frp_weight = 1;
 575             rpath.frp_proto = FIB_PROTOCOL_IP6;
 576         }
 577         else if (unformat (line_input, "via %U",
 578                            unformat_ip6_address,
 579                            &rpath.frp_addr.ip6))
 580         {
 581             rpath.frp_fib_index = 0;
 582             rpath.frp_weight = 1;
 583             rpath.frp_sw_if_index = ~0;
 584             rpath.frp_proto = FIB_PROTOCOL_IP6;
 585         }
 586         else if (unformat (line_input, "via %U",
 587                            unformat_ip4_address,
 588                            &rpath.frp_addr.ip4))
 589         {
 590             rpath.frp_fib_index = 0;
 591             rpath.frp_weight = 1;
 592             rpath.frp_sw_if_index = ~0;
 593             rpath.frp_proto = FIB_PROTOCOL_IP4;
 594         }
 595         else if (unformat (line_input, "l2-only"))
 596             l2_only = 1;
 597         else
 598             return clib_error_return (0, "unknown input '%U'",
 599                                       format_unformat_error, line_input);
 600     }
 601
 602     if (is_del)
 603     {
 604         vnet_mpls_tunnel_del(sw_if_index);
 605     }
 606     else
 607     {
 608         if (0 == vec_len(labels))
 609             return clib_error_return (0, "No Output Labels '%U'",
 610                                       format_unformat_error, line_input);
 611
 612         vec_add1(rpaths, rpath);
 613         vnet_mpls_tunnel_add(rpaths, labels, l2_only, &sw_if_index);
 614     }
 615
 616     vec_free(labels);
 617     vec_free(rpaths);
 618
 619     return (NULL);
 620 }
 621
 622 /*?
 623  * This command create a uni-directional MPLS tunnel
 624  *
 625  * @cliexpar
 626  * @cliexstart{create mpls tunnel}
 627  *  create mpls tunnel via 10.0.0.1 GigEthernet0/8/0 out-label 33 out-label 34
 628  * @cliexend
 629  ?*/
 630 VLIB_CLI_COMMAND (create_mpls_tunnel_command, static) = {
 631   .path = "mpls tunnel",
 632   .short_help =
 633   "mpls tunnel via [addr] [interface] [out-labels]",
 634   .function = vnet_create_mpls_tunnel_command_fn,
 635 };
 636
 637 static u8 *
 638 format_mpls_tunnel (u8 * s, va_list * args)
 639 {
 640     mpls_tunnel_t *mt = va_arg (*args, mpls_tunnel_t *);
 641     int ii;
 642
 643     s = format(s, "mpls_tunnel%d: sw_if_index:%d hw_if_index:%d",
 644                mt - mpls_tunnel_pool,
 645                mt->mt_sw_if_index,
 646                mt->mt_hw_if_index);
 647     s = format(s, "\n label-stack:\n  ");
 648     for (ii = 0; ii < vec_len(mt->mt_label_stack); ii++)
 649     {
 650         s = format(s, "%d, ", mt->mt_label_stack[ii]);
 651     }
 652     s = format(s, "\n via:\n");
 653     s = fib_path_list_format(mt->mt_path_list, s);
 654     s = format(s, "\n");
 655
 656     return (s);
 657 }
 658
 659 static clib_error_t *
 660 show_mpls_tunnel_command_fn (vlib_main_t * vm,
 661                              unformat_input_t * input,
 662                              vlib_cli_command_t * cmd)
 663 {
 664     mpls_tunnel_t * mt;
 665     u32 mti = ~0;
 666
 667     if (pool_elts (mpls_tunnel_pool) == 0)
 668         vlib_cli_output (vm, "No MPLS tunnels configured...");
 669
 670     while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 671     {
 672         if (unformat (input, "%d", &mti))
 673             ;
 674         else
 675             break;
 676     }
 677
 678     if (~0 == mti)
 679     {
 680         pool_foreach (mt, mpls_tunnel_pool,
 681         ({
 682             vlib_cli_output (vm, "[@%d] %U",
 683                              mt - mpls_tunnel_pool,
 684                              format_mpls_tunnel, mt);
 685         }));
 686     }
 687     else
 688     {
 689         if (pool_is_free_index(mpls_tunnel_pool, mti))
 690             return clib_error_return (0, "Not atunnel index %d", mti);
 691
 692         mt = pool_elt_at_index(mpls_tunnel_pool, mti);
 693
 694         vlib_cli_output (vm, "[@%d] %U",
 695                          mt - mpls_tunnel_pool,
 696                          format_mpls_tunnel, mt);
 697     }
 698
 699     return 0;
 700 }
 701
 702 /*?
 703  * This command to show MPLS tunnels
 704  *
 705  * @cliexpar
 706  * @cliexstart{sh mpls tunnel 2}
 707  * [@2] mpls_tunnel2: sw_if_index:5 hw_if_index:5
 708  *  label-stack:
 709  *    3,
 710  *  via:
 711  *   index:26 locks:1 proto:ipv4 uPRF-list:26 len:1 itfs:[2, ]
 712  *     index:26 pl-index:26 ipv4 weight=1 attached-nexthop:  oper-flags:resolved,
 713  *      10.0.0.2 loop0
 714  *         [@0]: ipv4 via 10.0.0.2 loop0: IP4: de:ad:00:00:00:00 -> 00:00:11:aa:bb:cc
 715  * @cliexend
 716  ?*/
 717 VLIB_CLI_COMMAND (show_mpls_tunnel_command, static) = {
 718     .path = "show mpls tunnel",
 719     .function = show_mpls_tunnel_command_fn,
 720 };
 721
 722 static mpls_tunnel_t *
 723 mpls_tunnel_from_fib_node (fib_node_t *node)
 724 {
 725 #if (CLIB_DEBUG > 0)
 726     ASSERT(FIB_NODE_TYPE_MPLS_TUNNEL == node->fn_type);
 727 #endif
 728     return ((mpls_tunnel_t*) (((char*)node) -
 729                              STRUCT_OFFSET_OF(mpls_tunnel_t, mt_node)));
 730 }
 731
 732 /**
 733  * Function definition to backwalk a FIB node
 734  */
 735 static fib_node_back_walk_rc_t
 736 mpls_tunnel_back_walk (fib_node_t *node,
 737                       fib_node_back_walk_ctx_t *ctx)
 738 {
 739     mpls_tunnel_restack(mpls_tunnel_from_fib_node(node));
 740
 741     return (FIB_NODE_BACK_WALK_CONTINUE);
 742 }
 743
 744 /**
 745  * Function definition to get a FIB node from its index
 746  */
 747 static fib_node_t*
 748 mpls_tunnel_fib_node_get (fib_node_index_t index)
 749 {
 750     mpls_tunnel_t * mt;
 751
 752     mt = pool_elt_at_index(mpls_tunnel_pool, index);
 753
 754     return (&mt->mt_node);
 755 }
 756
 757 /**
 758  * Function definition to inform the FIB node that its last lock has gone.
 759  */
 760 static void
 761 mpls_tunnel_last_lock_gone (fib_node_t *node)
 762 {
 763     /*
 764      * The MPLS MPLS tunnel is a root of the graph. As such
 765      * it never has children and thus is never locked.
 766      */
 767     ASSERT(0);
 768 }
 769
 770 /*
 771  * Virtual function table registered by MPLS MPLS tunnels
 772  * for participation in the FIB object graph.
 773  */
 774 const static fib_node_vft_t mpls_vft = {
 775     .fnv_get = mpls_tunnel_fib_node_get,
 776     .fnv_last_lock = mpls_tunnel_last_lock_gone,
 777     .fnv_back_walk = mpls_tunnel_back_walk,
 778 };
 779
 780 static clib_error_t *
 781 mpls_tunnel_init (vlib_main_t *vm)
 782 {
 783   fib_node_register_type(FIB_NODE_TYPE_MPLS_TUNNEL, &mpls_vft);
 784
 785   return 0;
 786 }
 787 VLIB_INIT_FUNCTION(mpls_tunnel_init);