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