src/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/mpls/mpls_types.h>
  22 #include <vnet/ip/ip.h>
  23 #include <vnet/fib/fib_path_list.h>
  24 #include <vnet/adj/adj_midchain.h>
  25 #include <vnet/adj/adj_mcast.h>
  26 #include <vnet/dpo/replicate_dpo.h>
  27 #include <vnet/fib/mpls_fib.h>
  28
  29 /**
  30  * @brief pool of tunnel instances
  31  */
  32 static mpls_tunnel_t *mpls_tunnel_pool;
  33
  34 /**
  35  * @brief DB of SW index to tunnel index
  36  */
  37 static u32 *mpls_tunnel_db;
  38
  39 /**
  40  * @brief MPLS tunnel flags strings
  41  */
  42 static const char *mpls_tunnel_attribute_names[] = MPLS_TUNNEL_ATTRIBUTES;
  43
  44 /**
  45  * @brief Get a tunnel object from a SW interface index
  46  */
  47 static mpls_tunnel_t*
  48 mpls_tunnel_get_from_sw_if_index (u32 sw_if_index)
  49 {
  50     if ((vec_len(mpls_tunnel_db) <= sw_if_index) ||
  51         (~0 == mpls_tunnel_db[sw_if_index]))
  52         return (NULL);
  53
  54     return (pool_elt_at_index(mpls_tunnel_pool,
  55                               mpls_tunnel_db[sw_if_index]));
  56 }
  57
  58 /**
  59  * @brief Build a rewrite string for the MPLS tunnel.
  60  */
  61 static u8*
  62 mpls_tunnel_build_rewrite_i (void)
  63 {
  64     /*
  65      * passing the adj code a NULL rewirte means 'i don't have one cos
  66      * t'other end is unresolved'. That's not the case here. For the mpls
  67      * tunnel there are just no bytes of encap to apply in the adj. We'll impose
  68      * the label stack once we choose a path. So return a zero length rewrite.
  69      */
  70     u8 *rewrite = NULL;
  71
  72     vec_validate(rewrite, 0);
  73     vec_reset_length(rewrite);
  74
  75     return (rewrite);
  76 }
  77
  78 /**
  79  * @brief Build a rewrite string for the MPLS tunnel.
  80  */
  81 static u8*
  82 mpls_tunnel_build_rewrite (vnet_main_t * vnm,
  83                            u32 sw_if_index,
  84                            vnet_link_t link_type,
  85                            const void *dst_address)
  86 {
  87     return (mpls_tunnel_build_rewrite_i());
  88 }
  89
  90 typedef struct mpls_tunnel_collect_forwarding_ctx_t_
  91 {
  92     load_balance_path_t * next_hops;
  93     const mpls_tunnel_t *mt;
  94     fib_forward_chain_type_t fct;
  95 } mpls_tunnel_collect_forwarding_ctx_t;
  96
  97 static fib_path_list_walk_rc_t
  98 mpls_tunnel_collect_forwarding (fib_node_index_t pl_index,
  99                                 fib_node_index_t path_index,
 100                                 void *arg)
 101 {
 102     mpls_tunnel_collect_forwarding_ctx_t *ctx;
 103     fib_path_ext_t *path_ext;
 104
 105     ctx = arg;
 106
 107     /*
 108      * if the path is not resolved, don't include it.
 109      */
 110     if (!fib_path_is_resolved(path_index))
 111     {
 112         return (FIB_PATH_LIST_WALK_CONTINUE);
 113     }
 114
 115     /*
 116      * get the matching path-extension for the path being visited.
 117      */
 118     path_ext = fib_path_ext_list_find_by_path_index(&ctx->mt->mt_path_exts,
 119                                                     path_index);
 120
 121     /*
 122      * we don't want IP TTL decrements for packets hitting the MPLS labels
 123      * we stack on, since the IP TTL decrement is done by the adj
 124      */
 125     path_ext->fpe_mpls_flags |= FIB_PATH_EXT_MPLS_FLAG_NO_IP_TTL_DECR;
 126
 127     /*
 128      * found a matching extension. stack it to obtain the forwarding
 129      * info for this path.
 130      */
 131     ctx->next_hops = fib_path_ext_stack(path_ext,
 132                                         ctx->fct,
 133                                         ctx->fct,
 134                                         ctx->next_hops);
 135
 136     return (FIB_PATH_LIST_WALK_CONTINUE);
 137 }
 138
 139 static void
 140 mpls_tunnel_mk_lb (mpls_tunnel_t *mt,
 141                    vnet_link_t linkt,
 142                    fib_forward_chain_type_t fct,
 143                    dpo_id_t *dpo_lb)
 144 {
 145     dpo_proto_t lb_proto;
 146
 147     /*
 148      * If the entry has path extensions then we construct a load-balance
 149      * by stacking the extensions on the forwarding chains of the paths.
 150      * Otherwise we use the load-balance of the path-list
 151      */
 152     mpls_tunnel_collect_forwarding_ctx_t ctx = {
 153         .mt = mt,
 154         .next_hops = NULL,
 155         .fct = fct,
 156     };
 157
 158     /*
 159      * As an optimisation we allocate the vector of next-hops to be sized
 160      * equal to the maximum nuber of paths we will need, which is also the
 161      * most likely number we will need, since in most cases the paths are 'up'.
 162      */
 163     vec_validate(ctx.next_hops, fib_path_list_get_n_paths(mt->mt_path_list));
 164     vec_reset_length(ctx.next_hops);
 165
 166     lb_proto = fib_forw_chain_type_to_dpo_proto(fct);
 167
 168     if (FIB_NODE_INDEX_INVALID != mt->mt_path_list)
 169     {
 170         fib_path_list_walk(mt->mt_path_list,
 171                            mpls_tunnel_collect_forwarding,
 172                            &ctx);
 173     }
 174
 175     if (!dpo_id_is_valid(dpo_lb))
 176     {
 177         /*
 178          * first time create
 179          */
 180         if (mt->mt_flags & MPLS_TUNNEL_FLAG_MCAST)
 181         {
 182             dpo_set(dpo_lb,
 183                     DPO_REPLICATE,
 184                     lb_proto,
 185                     replicate_create(0, lb_proto));
 186         }
 187         else
 188         {
 189             flow_hash_config_t fhc;
 190
 191             switch (linkt)
 192             {
 193             case VNET_LINK_MPLS:
 194                 fhc = MPLS_FLOW_HASH_DEFAULT;
 195                 break;
 196             case VNET_LINK_IP4:
 197             case VNET_LINK_IP6:
 198                 fhc = IP_FLOW_HASH_DEFAULT;
 199                 break;
 200             default:
 201                 fhc = 0;
 202                 break;
 203             }
 204
 205             dpo_set(dpo_lb,
 206                     DPO_LOAD_BALANCE,
 207                     lb_proto,
 208                     load_balance_create(0, lb_proto, fhc));
 209         }
 210     }
 211
 212     if (mt->mt_flags & MPLS_TUNNEL_FLAG_MCAST)
 213     {
 214         /*
 215          * MPLS multicast
 216          */
 217         replicate_multipath_update(dpo_lb, ctx.next_hops);
 218     }
 219     else
 220     {
 221         load_balance_multipath_update(dpo_lb,
 222                                       ctx.next_hops,
 223                                       LOAD_BALANCE_FLAG_NONE);
 224         vec_free(ctx.next_hops);
 225     }
 226 }
 227
 228 /**
 229  * mpls_tunnel_stack
 230  *
 231  * 'stack' (resolve the recursion for) the tunnel's midchain adjacency
 232  */
 233 static void
 234 mpls_tunnel_stack (adj_index_t ai)
 235 {
 236     ip_adjacency_t *adj;
 237     mpls_tunnel_t *mt;
 238     u32 sw_if_index;
 239
 240     adj = adj_get(ai);
 241     sw_if_index = adj->rewrite_header.sw_if_index;
 242
 243     mt = mpls_tunnel_get_from_sw_if_index(sw_if_index);
 244
 245     if (NULL == mt)
 246         return;
 247
 248     /*
 249      * while we're stacking the adj, remove the tunnel from the child list
 250      * of the path list. this breaks a circular dependency of walk updates
 251      * where the create of adjacencies in the children can lead to walks
 252      * that get back here.
 253      */
 254     fib_path_list_lock(mt->mt_path_list);
 255
 256     fib_path_list_child_remove(mt->mt_path_list,
 257                                mt->mt_sibling_index);
 258
 259     /*
 260      * Construct the DPO (load-balance or replicate) that we can stack
 261      * the tunnel's midchain on
 262      */
 263     if (vnet_hw_interface_get_flags(vnet_get_main(),
 264                                     mt->mt_hw_if_index) &
 265         VNET_HW_INTERFACE_FLAG_LINK_UP)
 266     {
 267         dpo_id_t dpo = DPO_INVALID;
 268
 269         mpls_tunnel_mk_lb(mt,
 270                           adj->ia_link,
 271                           fib_forw_chain_type_from_link_type(
 272                               adj_get_link_type(ai)),
 273                           &dpo);
 274
 275         adj_nbr_midchain_stack(ai, &dpo);
 276         dpo_reset(&dpo);
 277     }
 278     else
 279     {
 280         adj_nbr_midchain_unstack(ai);
 281     }
 282
 283     mt->mt_sibling_index = fib_path_list_child_add(mt->mt_path_list,
 284                                                    FIB_NODE_TYPE_MPLS_TUNNEL,
 285                                                    mt - mpls_tunnel_pool);
 286
 287     fib_path_list_unlock(mt->mt_path_list);
 288 }
 289
 290 /**
 291  * @brief Call back when restacking all adjacencies on a MPLS interface
 292  */
 293 static adj_walk_rc_t
 294 mpls_adj_walk_cb (adj_index_t ai,
 295                  void *ctx)
 296 {
 297     mpls_tunnel_stack(ai);
 298
 299     return (ADJ_WALK_RC_CONTINUE);
 300 }
 301
 302 static void
 303 mpls_tunnel_restack (mpls_tunnel_t *mt)
 304 {
 305     fib_protocol_t proto;
 306
 307     /*
 308      * walk all the adjacencies on the MPLS interface and restack them
 309      */
 310     if (mt->mt_flags & MPLS_TUNNEL_FLAG_L2)
 311     {
 312         /*
 313          * Stack a load-balance that drops, whilst we have no paths
 314          */
 315         vnet_hw_interface_t * hi;
 316         dpo_id_t dpo = DPO_INVALID;
 317
 318         mpls_tunnel_mk_lb(mt,
 319                           VNET_LINK_MPLS,
 320                           FIB_FORW_CHAIN_TYPE_ETHERNET,
 321                           &dpo);
 322
 323         hi = vnet_get_hw_interface(vnet_get_main(), mt->mt_hw_if_index);
 324         dpo_stack_from_node(hi->tx_node_index,
 325                             &mt->mt_l2_lb,
 326                             &dpo);
 327         dpo_reset(&dpo);
 328     }
 329     else
 330     {
 331         FOR_EACH_FIB_PROTOCOL(proto)
 332         {
 333             adj_nbr_walk(mt->mt_sw_if_index,
 334                          proto,
 335                          mpls_adj_walk_cb,
 336                          NULL);
 337         }
 338     }
 339 }
 340
 341 static clib_error_t *
 342 mpls_tunnel_admin_up_down (vnet_main_t * vnm,
 343                            u32 hw_if_index,
 344                            u32 flags)
 345 {
 346     vnet_hw_interface_t * hi;
 347     mpls_tunnel_t *mt;
 348
 349     hi = vnet_get_hw_interface (vnm, hw_if_index);
 350
 351     mt = mpls_tunnel_get_from_sw_if_index(hi->sw_if_index);
 352
 353     if (NULL == mt)
 354         return (NULL);
 355
 356     if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
 357         vnet_hw_interface_set_flags (vnm, hw_if_index,
 358                                      VNET_HW_INTERFACE_FLAG_LINK_UP);
 359     else
 360         vnet_hw_interface_set_flags (vnm, hw_if_index, 0 /* down */);
 361
 362     mpls_tunnel_restack(mt);
 363
 364     return (NULL);
 365 }
 366
 367 /**
 368  * @brief Fixup the adj rewrite post encap. This is a no-op since the
 369  * rewrite is a stack of labels.
 370  */
 371 static void
 372 mpls_tunnel_fixup (vlib_main_t *vm,
 373                    ip_adjacency_t *adj,
 374                    vlib_buffer_t *b0,
 375                    const void*data)
 376 {
 377     /*
 378      * A no-op w.r.t. the header. but reset the 'have we pushed any
 379      * MPLS labels onto the packet' flag. That way when we enter the
 380      * tunnel we'll get a TTL set to 255
 381      */
 382     vnet_buffer(b0)->mpls.first = 0;
 383 }
 384
 385 static void
 386 mpls_tunnel_update_adj (vnet_main_t * vnm,
 387                         u32 sw_if_index,
 388                         adj_index_t ai)
 389 {
 390     ip_adjacency_t *adj;
 391
 392     ASSERT(ADJ_INDEX_INVALID != ai);
 393
 394     adj = adj_get(ai);
 395
 396     switch (adj->lookup_next_index)
 397     {
 398     case IP_LOOKUP_NEXT_ARP:
 399     case IP_LOOKUP_NEXT_GLEAN:
 400     case IP_LOOKUP_NEXT_BCAST:
 401         adj_nbr_midchain_update_rewrite(ai, mpls_tunnel_fixup,
 402                                         NULL,
 403                                         ADJ_FLAG_NONE,
 404                                         mpls_tunnel_build_rewrite_i());
 405         break;
 406     case IP_LOOKUP_NEXT_MCAST:
 407         /*
 408          * Construct a partial rewrite from the known ethernet mcast dest MAC
 409          * There's no MAC fixup, so the last 2 parameters are 0
 410          */
 411         adj_mcast_midchain_update_rewrite(ai, mpls_tunnel_fixup,
 412                                           NULL,
 413                                           ADJ_FLAG_NONE,
 414                                           mpls_tunnel_build_rewrite_i(),
 415                                           0, 0);
 416         break;
 417
 418     case IP_LOOKUP_NEXT_DROP:
 419     case IP_LOOKUP_NEXT_PUNT:
 420     case IP_LOOKUP_NEXT_LOCAL:
 421     case IP_LOOKUP_NEXT_REWRITE:
 422     case IP_LOOKUP_NEXT_MIDCHAIN:
 423     case IP_LOOKUP_NEXT_MCAST_MIDCHAIN:
 424     case IP_LOOKUP_NEXT_ICMP_ERROR:
 425     case IP_LOOKUP_N_NEXT:
 426       ASSERT (0);
 427       break;
 428     }
 429
 430     mpls_tunnel_stack(ai);
 431 }
 432
 433 static u8 *
 434 format_mpls_tunnel_name (u8 * s, va_list * args)
 435 {
 436   u32 dev_instance = va_arg (*args, u32);
 437   return format (s, "mpls-tunnel%d", dev_instance);
 438 }
 439
 440 static u8 *
 441 format_mpls_tunnel_device (u8 * s, va_list * args)
 442 {
 443   u32 dev_instance = va_arg (*args, u32);
 444   CLIB_UNUSED (int verbose) = va_arg (*args, int);
 445
 446   return (format (s, "MPLS-tunnel: id %d\n", dev_instance));
 447 }
 448
 449 /**
 450  * @brief Packet trace structure
 451  */
 452 typedef struct mpls_tunnel_trace_t_
 453 {
 454     /**
 455    * Tunnel-id / index in tunnel vector
 456    */
 457   u32 tunnel_id;
 458 } mpls_tunnel_trace_t;
 459
 460 static u8 *
 461 format_mpls_tunnel_tx_trace (u8 * s,
 462                              va_list * args)
 463 {
 464   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
 465   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
 466   mpls_tunnel_trace_t * t = va_arg (*args, mpls_tunnel_trace_t *);
 467
 468   s = format (s, "MPLS: tunnel %d", t->tunnel_id);
 469   return s;
 470 }
 471
 472 /**
 473  * @brief TX function. Only called L2. L3 traffic uses the adj-midchains
 474  */
 475 static uword
 476 mpls_tunnel_tx (vlib_main_t * vm,
 477                 vlib_node_runtime_t * node,
 478                 vlib_frame_t * frame)
 479 {
 480   u32 next_index;
 481   u32 * from, * to_next, n_left_from, n_left_to_next;
 482   vnet_interface_output_runtime_t * rd = (void *) node->runtime_data;
 483   const mpls_tunnel_t *mt;
 484
 485   mt = pool_elt_at_index(mpls_tunnel_pool, rd->dev_instance);
 486
 487   /* Vector of buffer / pkt indices we're supposed to process */
 488   from = vlib_frame_vector_args (frame);
 489
 490   /* Number of buffers / pkts */
 491   n_left_from = frame->n_vectors;
 492
 493   /* Speculatively send the first buffer to the last disposition we used */
 494   next_index = node->cached_next_index;
 495
 496   while (n_left_from > 0)
 497     {
 498       /* set up to enqueue to our disposition with index = next_index */
 499       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 500
 501       /*
 502        * FIXME DUAL LOOP
 503        */
 504       while (n_left_from > 0 && n_left_to_next > 0)
 505         {
 506           vlib_buffer_t * b0;
 507           u32 bi0;
 508
 509           bi0 = from[0];
 510           to_next[0] = bi0;
 511           from += 1;
 512           to_next += 1;
 513           n_left_from -= 1;
 514           n_left_to_next -= 1;
 515
 516           b0 = vlib_get_buffer(vm, bi0);
 517
 518           vnet_buffer(b0)->ip.adj_index[VLIB_TX] = mt->mt_l2_lb.dpoi_index;
 519           /* since we are coming out of the L2 world, where the vlib_buffer
 520            * union is used for other things, make sure it is clean for
 521            * MPLS from now on.
 522            */
 523           vnet_buffer(b0)->mpls.first = 0;
 524
 525           if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
 526             {
 527               mpls_tunnel_trace_t *tr = vlib_add_trace (vm, node,
 528                                                    b0, sizeof (*tr));
 529               tr->tunnel_id = rd->dev_instance;
 530             }
 531
 532           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 533                                            to_next, n_left_to_next,
 534                                            bi0, mt->mt_l2_lb.dpoi_next_node);
 535         }
 536
 537       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 538     }
 539
 540   return frame->n_vectors;
 541 }
 542
 543 VNET_DEVICE_CLASS (mpls_tunnel_class) = {
 544     .name = "MPLS tunnel device",
 545     .format_device_name = format_mpls_tunnel_name,
 546     .format_device = format_mpls_tunnel_device,
 547     .format_tx_trace = format_mpls_tunnel_tx_trace,
 548     .tx_function = mpls_tunnel_tx,
 549     .admin_up_down_function = mpls_tunnel_admin_up_down,
 550 };
 551
 552 VNET_HW_INTERFACE_CLASS (mpls_tunnel_hw_interface_class) = {
 553   .name = "MPLS-Tunnel",
 554   .update_adjacency = mpls_tunnel_update_adj,
 555   .build_rewrite = mpls_tunnel_build_rewrite,
 556   .flags = VNET_HW_INTERFACE_CLASS_FLAG_P2P,
 557 };
 558
 559 const mpls_tunnel_t *
 560 mpls_tunnel_get (u32 mti)
 561 {
 562     return (pool_elt_at_index(mpls_tunnel_pool, mti));
 563 }
 564
 565 /**
 566  * @brief Walk all the MPLS tunnels
 567  */
 568 void
 569 mpls_tunnel_walk (mpls_tunnel_walk_cb_t cb,
 570                   void *ctx)
 571 {
 572     u32 mti;
 573
 574     pool_foreach_index(mti, mpls_tunnel_pool,
 575     ({
 576         cb(mti, ctx);
 577     }));
 578 }
 579
 580 void
 581 vnet_mpls_tunnel_del (u32 sw_if_index)
 582 {
 583     mpls_tunnel_t *mt;
 584
 585     mt = mpls_tunnel_get_from_sw_if_index(sw_if_index);
 586
 587     if (NULL == mt)
 588         return;
 589
 590     if (FIB_NODE_INDEX_INVALID != mt->mt_path_list)
 591         fib_path_list_child_remove(mt->mt_path_list,
 592                                    mt->mt_sibling_index);
 593     dpo_reset(&mt->mt_l2_lb);
 594
 595     vnet_delete_hw_interface (vnet_get_main(), mt->mt_hw_if_index);
 596
 597     pool_put(mpls_tunnel_pool, mt);
 598     mpls_tunnel_db[sw_if_index] = ~0;
 599 }
 600
 601 u32
 602 vnet_mpls_tunnel_create (u8 l2_only,
 603                          u8 is_multicast)
 604 {
 605     vnet_hw_interface_t * hi;
 606     mpls_tunnel_t *mt;
 607     vnet_main_t * vnm;
 608     u32 mti;
 609
 610     vnm = vnet_get_main();
 611     pool_get(mpls_tunnel_pool, mt);
 612     memset (mt, 0, sizeof (*mt));
 613     mti = mt - mpls_tunnel_pool;
 614     fib_node_init(&mt->mt_node, FIB_NODE_TYPE_MPLS_TUNNEL);
 615     mt->mt_path_list = FIB_NODE_INDEX_INVALID;
 616     mt->mt_sibling_index = FIB_NODE_INDEX_INVALID;
 617
 618     if (is_multicast)
 619         mt->mt_flags |= MPLS_TUNNEL_FLAG_MCAST;
 620     if (l2_only)
 621         mt->mt_flags |= MPLS_TUNNEL_FLAG_L2;
 622
 623     /*
 624      * Create a new tunnel HW interface
 625      */
 626     mt->mt_hw_if_index = vnet_register_interface(
 627         vnm,
 628         mpls_tunnel_class.index,
 629         mti,
 630         mpls_tunnel_hw_interface_class.index,
 631         mti);
 632     hi = vnet_get_hw_interface (vnm, mt->mt_hw_if_index);
 633
 634     /* Standard default MPLS tunnel MTU. */
 635     vnet_sw_interface_set_mtu (vnm, hi->sw_if_index, 9000);
 636
 637     /*
 638      * Add the new tunnel to the tunnel DB - key:SW if index
 639      */
 640     mt->mt_sw_if_index = hi->sw_if_index;
 641     vec_validate_init_empty(mpls_tunnel_db, mt->mt_sw_if_index, ~0);
 642     mpls_tunnel_db[mt->mt_sw_if_index] = mti;
 643
 644     return (mt->mt_sw_if_index);
 645 }
 646
 647 void
 648 vnet_mpls_tunnel_path_add (u32 sw_if_index,
 649                            fib_route_path_t *rpaths)
 650 {
 651     mpls_tunnel_t *mt;
 652     u32 mti;
 653
 654     mt = mpls_tunnel_get_from_sw_if_index(sw_if_index);
 655
 656     if (NULL == mt)
 657         return;
 658
 659     mti = mt - mpls_tunnel_pool;
 660
 661     /*
 662      * construct a path-list from the path provided
 663      */
 664     if (FIB_NODE_INDEX_INVALID == mt->mt_path_list)
 665     {
 666         mt->mt_path_list = fib_path_list_create(FIB_PATH_LIST_FLAG_SHARED, rpaths);
 667         mt->mt_sibling_index = fib_path_list_child_add(mt->mt_path_list,
 668                                                        FIB_NODE_TYPE_MPLS_TUNNEL,
 669                                                        mti);
 670     }
 671     else
 672     {
 673         fib_node_index_t old_pl_index;
 674
 675         old_pl_index = mt->mt_path_list;
 676
 677         mt->mt_path_list =
 678             fib_path_list_copy_and_path_add(old_pl_index,
 679                                             FIB_PATH_LIST_FLAG_SHARED,
 680                                             rpaths);
 681
 682         fib_path_list_child_remove(old_pl_index,
 683                                    mt->mt_sibling_index);
 684         mt->mt_sibling_index = fib_path_list_child_add(mt->mt_path_list,
 685                                                        FIB_NODE_TYPE_MPLS_TUNNEL,
 686                                                        mti);
 687         /*
 688          * re-resolve all the path-extensions with the new path-list
 689          */
 690         fib_path_ext_list_resolve(&mt->mt_path_exts, mt->mt_path_list);
 691     }
 692     fib_path_ext_list_insert(&mt->mt_path_exts,
 693                              mt->mt_path_list,
 694                              FIB_PATH_EXT_MPLS,
 695                              rpaths);
 696     mpls_tunnel_restack(mt);
 697 }
 698
 699 int
 700 vnet_mpls_tunnel_path_remove (u32 sw_if_index,
 701                               fib_route_path_t *rpaths)
 702 {
 703     mpls_tunnel_t *mt;
 704     u32 mti;
 705
 706     mt = mpls_tunnel_get_from_sw_if_index(sw_if_index);
 707
 708     if (NULL == mt)
 709         return (0);
 710
 711     mti = mt - mpls_tunnel_pool;
 712
 713     /*
 714      * construct a path-list from the path provided
 715      */
 716     if (FIB_NODE_INDEX_INVALID == mt->mt_path_list)
 717     {
 718         /* can't remove a path if we have onoe */
 719         return (0);
 720     }
 721     else
 722     {
 723         fib_node_index_t old_pl_index;
 724
 725         old_pl_index = mt->mt_path_list;
 726
 727         mt->mt_path_list =
 728             fib_path_list_copy_and_path_remove(old_pl_index,
 729                                                FIB_PATH_LIST_FLAG_SHARED,
 730                                                rpaths);
 731
 732         fib_path_list_child_remove(old_pl_index,
 733                                    mt->mt_sibling_index);
 734
 735         if (FIB_NODE_INDEX_INVALID == mt->mt_path_list)
 736         {
 737             /* no paths left */
 738             return (0);
 739         }
 740         else
 741         {
 742             mt->mt_sibling_index =
 743                 fib_path_list_child_add(mt->mt_path_list,
 744                                         FIB_NODE_TYPE_MPLS_TUNNEL,
 745                                         mti);
 746         }
 747         /*
 748          * find the matching path extension and remove it
 749          */
 750         fib_path_ext_list_remove(&mt->mt_path_exts,
 751                                   FIB_PATH_EXT_MPLS,
 752                                   rpaths);
 753
 754         /*
 755          * re-resolve all the path-extensions with the new path-list
 756          */
 757         fib_path_ext_list_resolve(&mt->mt_path_exts,
 758                                   mt->mt_path_list);
 759
 760         mpls_tunnel_restack(mt);
 761    }
 762
 763     return (fib_path_list_get_n_paths(mt->mt_path_list));
 764 }
 765
 766 int
 767 vnet_mpls_tunnel_get_index (u32 sw_if_index)
 768 {
 769     mpls_tunnel_t *mt;
 770
 771     mt = mpls_tunnel_get_from_sw_if_index(sw_if_index);
 772
 773     if (NULL == mt)
 774         return (~0);
 775
 776     return (mt - mpls_tunnel_pool);
 777 }
 778
 779 static clib_error_t *
 780 vnet_create_mpls_tunnel_command_fn (vlib_main_t * vm,
 781                                     unformat_input_t * input,
 782                                     vlib_cli_command_t * cmd)
 783 {
 784     unformat_input_t _line_input, * line_input = &_line_input;
 785     vnet_main_t * vnm = vnet_get_main();
 786     u8 is_del = 0, l2_only = 0, is_multicast =0;
 787     fib_route_path_t rpath, *rpaths = NULL;
 788     u32 sw_if_index = ~0, payload_proto;
 789     clib_error_t *error = NULL;
 790
 791     memset(&rpath, 0, sizeof(rpath));
 792     payload_proto = DPO_PROTO_MPLS;
 793
 794     /* Get a line of input. */
 795     if (! unformat_user (input, unformat_line_input, line_input))
 796         return 0;
 797
 798     while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 799     {
 800         if (unformat (line_input, "del %U",
 801                       unformat_vnet_sw_interface, vnm,
 802                       &sw_if_index))
 803             is_del = 1;
 804         else if (unformat (line_input, "add %U",
 805                            unformat_vnet_sw_interface, vnm,
 806                            &sw_if_index))
 807             is_del = 0;
 808         else if (unformat (line_input, "add"))
 809             is_del = 0;
 810         else if (unformat (line_input, "l2-only"))
 811             l2_only = 1;
 812         else if (unformat (line_input, "multicast"))
 813             is_multicast = 1;
 814         else if (unformat (line_input, "via %U",
 815                            unformat_fib_route_path,
 816                            &rpath, &payload_proto))
 817             vec_add1(rpaths, rpath);
 818         else
 819         {
 820             error = clib_error_return (0, "unknown input '%U'",
 821                                        format_unformat_error, line_input);
 822             goto done;
 823         }
 824     }
 825
 826     if (is_del)
 827     {
 828         if (NULL == rpaths)
 829         {
 830             vnet_mpls_tunnel_del(sw_if_index);
 831         }
 832         else if (!vnet_mpls_tunnel_path_remove(sw_if_index, rpaths))
 833         {
 834             vnet_mpls_tunnel_del(sw_if_index);
 835         }
 836     }
 837     else
 838     {
 839         if (0 == vec_len(rpath.frp_label_stack))
 840         {
 841             error = clib_error_return (0, "No Output Labels '%U'",
 842                                        format_unformat_error, line_input);
 843             goto done;
 844         }
 845
 846         if (~0 == sw_if_index)
 847         {
 848             sw_if_index = vnet_mpls_tunnel_create(l2_only, is_multicast);
 849         }
 850         vnet_mpls_tunnel_path_add(sw_if_index, rpaths);
 851     }
 852
 853 done:
 854     vec_free(rpaths);
 855     unformat_free (line_input);
 856
 857     return error;
 858 }
 859
 860 /*?
 861  * This command create a uni-directional MPLS tunnel
 862  *
 863  * @cliexpar
 864  * @cliexstart{create mpls tunnel}
 865  *  create mpls tunnel via 10.0.0.1 GigEthernet0/8/0 out-label 33 out-label 34
 866  * @cliexend
 867  ?*/
 868 VLIB_CLI_COMMAND (create_mpls_tunnel_command, static) = {
 869   .path = "mpls tunnel",
 870   .short_help =
 871   "mpls tunnel [multicast] [l2-only] via [next-hop-address] [next-hop-interface] [next-hop-table <value>] [weight <value>] [preference <value>] [udp-encap-id <value>] [ip4-lookup-in-table <value>] [ip6-lookup-in-table <value>] [mpls-lookup-in-table <value>] [resolve-via-host] [resolve-via-connected] [rx-ip4 <interface>] [out-labels <value value value>]",
 872   .function = vnet_create_mpls_tunnel_command_fn,
 873 };
 874
 875 static u8 *
 876 format_mpls_tunnel (u8 * s, va_list * args)
 877 {
 878     mpls_tunnel_t *mt = va_arg (*args, mpls_tunnel_t *);
 879     mpls_tunnel_attribute_t attr;
 880
 881     s = format(s, "mpls_tunnel%d: sw_if_index:%d hw_if_index:%d",
 882                mt - mpls_tunnel_pool,
 883                mt->mt_sw_if_index,
 884                mt->mt_hw_if_index);
 885     if (MPLS_TUNNEL_FLAG_NONE != mt->mt_flags) {
 886         s = format(s, " \n flags:");
 887         FOR_EACH_MPLS_TUNNEL_ATTRIBUTE(attr) {
 888             if ((1<<attr) & mt->mt_flags) {
 889                 s = format (s, "%s,", mpls_tunnel_attribute_names[attr]);
 890             }
 891         }
 892     }
 893     s = format(s, "\n via:\n");
 894     s = fib_path_list_format(mt->mt_path_list, s);
 895     s = format(s, "%U", format_fib_path_ext_list, &mt->mt_path_exts);
 896     s = format(s, "\n");
 897
 898     if (mt->mt_flags & MPLS_TUNNEL_FLAG_L2)
 899     {
 900         s = format(s, " forwarding: %U\n",
 901                    format_fib_forw_chain_type,
 902                    FIB_FORW_CHAIN_TYPE_ETHERNET);
 903         s = format(s, " %U\n", format_dpo_id, &mt->mt_l2_lb, 2);
 904     }
 905
 906     return (s);
 907 }
 908
 909 static clib_error_t *
 910 show_mpls_tunnel_command_fn (vlib_main_t * vm,
 911                              unformat_input_t * input,
 912                              vlib_cli_command_t * cmd)
 913 {
 914     mpls_tunnel_t * mt;
 915     u32 mti = ~0;
 916
 917     if (pool_elts (mpls_tunnel_pool) == 0)
 918         vlib_cli_output (vm, "No MPLS tunnels configured...");
 919
 920     while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 921     {
 922         if (unformat (input, "%d", &mti))
 923             ;
 924         else
 925             break;
 926     }
 927
 928     if (~0 == mti)
 929     {
 930         pool_foreach (mt, mpls_tunnel_pool,
 931         ({
 932             vlib_cli_output (vm, "[@%d] %U",
 933                              mt - mpls_tunnel_pool,
 934                              format_mpls_tunnel, mt);
 935         }));
 936     }
 937     else
 938     {
 939         if (pool_is_free_index(mpls_tunnel_pool, mti))
 940             return clib_error_return (0, "Not a tunnel index %d", mti);
 941
 942         mt = pool_elt_at_index(mpls_tunnel_pool, mti);
 943
 944         vlib_cli_output (vm, "[@%d] %U",
 945                          mt - mpls_tunnel_pool,
 946                          format_mpls_tunnel, mt);
 947     }
 948
 949     return 0;
 950 }
 951
 952 /*?
 953  * This command to show MPLS tunnels
 954  *
 955  * @cliexpar
 956  * @cliexstart{sh mpls tunnel 2}
 957  * [@2] mpls_tunnel2: sw_if_index:5 hw_if_index:5
 958  *  label-stack:
 959  *    3,
 960  *  via:
 961  *   index:26 locks:1 proto:ipv4 uPRF-list:26 len:1 itfs:[2, ]
 962  *     index:26 pl-index:26 ipv4 weight=1 attached-nexthop:  oper-flags:resolved,
 963  *      10.0.0.2 loop0
 964  *         [@0]: ipv4 via 10.0.0.2 loop0: IP4: de:ad:00:00:00:00 -> 00:00:11:aa:bb:cc
 965  * @cliexend
 966  ?*/
 967 VLIB_CLI_COMMAND (show_mpls_tunnel_command, static) = {
 968     .path = "show mpls tunnel",
 969     .function = show_mpls_tunnel_command_fn,
 970 };
 971
 972 static mpls_tunnel_t *
 973 mpls_tunnel_from_fib_node (fib_node_t *node)
 974 {
 975     ASSERT(FIB_NODE_TYPE_MPLS_TUNNEL == node->fn_type);
 976     return ((mpls_tunnel_t*) (((char*)node) -
 977                              STRUCT_OFFSET_OF(mpls_tunnel_t, mt_node)));
 978 }
 979
 980 /**
 981  * Function definition to backwalk a FIB node
 982  */
 983 static fib_node_back_walk_rc_t
 984 mpls_tunnel_back_walk (fib_node_t *node,
 985                       fib_node_back_walk_ctx_t *ctx)
 986 {
 987     mpls_tunnel_restack(mpls_tunnel_from_fib_node(node));
 988
 989     return (FIB_NODE_BACK_WALK_CONTINUE);
 990 }
 991
 992 /**
 993  * Function definition to get a FIB node from its index
 994  */
 995 static fib_node_t*
 996 mpls_tunnel_fib_node_get (fib_node_index_t index)
 997 {
 998     mpls_tunnel_t * mt;
 999
1000     mt = pool_elt_at_index(mpls_tunnel_pool, index);
1001
1002     return (&mt->mt_node);
1003 }
1004
1005 /**
1006  * Function definition to inform the FIB node that its last lock has gone.
1007  */
1008 static void
1009 mpls_tunnel_last_lock_gone (fib_node_t *node)
1010 {
1011     /*
1012      * The MPLS MPLS tunnel is a root of the graph. As such
1013      * it never has children and thus is never locked.
1014      */
1015     ASSERT(0);
1016 }
1017
1018 /*
1019  * Virtual function table registered by MPLS MPLS tunnels
1020  * for participation in the FIB object graph.
1021  */
1022 const static fib_node_vft_t mpls_vft = {
1023     .fnv_get = mpls_tunnel_fib_node_get,
1024     .fnv_last_lock = mpls_tunnel_last_lock_gone,
1025     .fnv_back_walk = mpls_tunnel_back_walk,
1026 };
1027
1028 static clib_error_t *
1029 mpls_tunnel_init (vlib_main_t *vm)
1030 {
1031   fib_node_register_type(FIB_NODE_TYPE_MPLS_TUNNEL, &mpls_vft);
1032
1033   return 0;
1034 }
1035 VLIB_INIT_FUNCTION(mpls_tunnel_init);