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